McEventCollectionCnv_p6 Class Reference

#include <McEventCollectionCnv_p6.h>

Inheritance diagram for McEventCollectionCnv_p6:

Collaboration diagram for McEventCollectionCnv_p6:

Public Types
typedef TRANS	Trans_t
typedef PERS	Pers_t
typedef PERS	PersBase_t
typedef TRANS	TransBase_t
typedef ITPConverterFor< TRANS >	PolyCnvBase_t
typedef Gaudi::PluginService::Factory< ITPCnvBase *()>	Factory

Public Member Functions
	McEventCollectionCnv_p6 ()
	Default constructor: More...
	McEventCollectionCnv_p6 (const McEventCollectionCnv_p6 &rhs)
	Copy constructor. More...
McEventCollectionCnv_p6 &	operator= (const McEventCollectionCnv_p6 &rhs)
	Assignement operator. More...
virtual	~McEventCollectionCnv_p6 ()
	Destructor. More...
void	setPileup ()
virtual void	persToTrans (const McEventCollection_p6 *persObj, McEventCollection *transObj, MsgStream &log)
	Method creating the transient representation of McEventCollection from its persistent representation McEventCollection_p6. More...
virtual void	transToPers (const McEventCollection *transObj, McEventCollection_p6 *persObj, MsgStream &log)
	Method creating the persistent representation McEventCollection_p6 from its transient representation McEventCollection. More...
virtual TPObjRef	virt_toPersistent (const TRANS *trans, MsgStream &log)
	Internal interface method that is used to invoke the real conversion method (toPersistent_impl) in the derived converter. More...
virtual TPObjRef	virt_toPersistentWithKey (const TRANS *trans, const std::string &key, MsgStream &log)
	Internal interface method that is used to invoke the real conversion method (toPersistent_impl) in the derived converter. More...
virtual void	pstoreToTrans (unsigned index, TRANS *trans, MsgStream &log)
	Convert persistent representation stored in the storage vector of the top-level object to transient. More...
virtual TRANS *	createTransient (const PERS *persObj, MsgStream &log)
	Create transient representation of a persistent object. More...
virtual TRANS *	createTransientWithKey (const PERS *persObj, const std::string &key, MsgStream &log)
	Create transient representation of a persistent object, with SG key. More...
virtual TRANS *	virt_createTransFromPStore (unsigned index, MsgStream &log)
	Internal interface method that is used to invoke the real conversion method (createTransient) More...
virtual TRANS *	virt_createTransFromPStoreWithKey (unsigned index, const std::string &key, MsgStream &log)
	Internal interface method that is used to invoke the real conversion method (createTransient) More...
virtual void	persToTrans (const PERS *persObj, TRANS *transObj, MsgStream &log)=0
	Convert persistent representation to transient one. More...
virtual void	transToPers (const TRANS *transObj, PERS *persObj, MsgStream &log)=0
	Convert transient representation to persistent one. More...
virtual void	persToTransWithKey (const PERS *persObj, TRANS *transObj, const std::string &, MsgStream &log)
	Convert persistent representation to transient one. More...
virtual void	transToPersWithKey (const TRANS *transObj, PERS *persObj, const std::string &, MsgStream &log)
	Convert transient representation to persistent one. More...
virtual void	persToTransUntyped (const void *pers, void *trans, MsgStream &log)
	Convert persistent object representation to transient. More...
virtual void	transToPersUntyped (const void *trans, void *pers, MsgStream &log)
	Convert transient object representation to persistent. More...
virtual void	persToTransWithKeyUntyped (const void *pers, void *trans, const std::string &key, MsgStream &log)
	Convert persistent object representation to transient. More...
virtual void	transToPersWithKeyUntyped (const void *trans, void *pers, const std::string &key, MsgStream &log)
	Convert transient object representation to persistent. More...
virtual PERS *	createPersistent (const TRANS *transObj, MsgStream &log)
	Create persistent representation of a transient object. More...
virtual PERS *	createPersistentWithKey (const TRANS *transObj, const std::string &key, MsgStream &log)
	Create persistent representation of a transient object, with SG key. More...
TPObjRef	toPersistentWithKey_impl (const TRANS *trans, const std::string &key, MsgStream &log)
	Convert transient object to persistent representation. More...
virtual const std::type_info &	transientTInfo () const
	return C++ type id of the transient class this converter is for More...
virtual const std::type_info &	transientTInfo () const
	return C++ type id of the transient class this converter is for More...
virtual const std::type_info &	persistentTInfo () const
	return C++ type id of the persistent class this converter is for More...
virtual const std::type_info &	persistentTInfo () const =0
	return C++ type id of the persistent class this converter is for More...
void	setPStorage (std::vector< PERS > *storage)
	Tell this converter which storage vector it should use to store or retrieve persistent representations. More...
void	setRecursive (bool flag=true)
	Tell the converter if it should work in recursive mode slower but it can safely handle recursion. More...
void	ignoreRecursion (bool flag=false)
	Tell the converter to ignore recursion (do not throw errors) even when recurion is detected. More...
virtual void	reservePStorage (size_t size)
	Reserve 'size' elements for persistent storage. More...
template<class CNV >
CNV *	converterForType (CNV *cnv, const std::type_info &t_info, MsgStream &log) const
	Find converter for a given C++ type ID, that is or ihnerits from CNV type. More...
template<class CNV >
CNV *	converterForRef (CNV *cnv, const TPObjRef &ref, MsgStream &log) const
	Find converter for a TP type ID (passed in a TP Ref), that is or ihnerits from CNV type. More...
template<class CNV >
TPObjRef	baseToPersistent (CNV **cnv, const typename CNV::Trans_t *transObj, MsgStream &log) const
	Persistify bass class of a given object and store the persistent represenation in the storage vector of the top-level persistent object. More...
template<class CNV >
TPObjRef	toPersistent (CNV **cnv, const typename CNV::TransBase_t *transObj, MsgStream &log) const
	Persistify an object and store the persistent represenation in the storage vector of the top-level persistent object. More...
template<class CNV , class TRANS_T >
void	fillTransFromPStore (CNV **cnv, const TPObjRef &ref, TRANS_T *trans, MsgStream &log) const
	Convert persistent object, stored in the the top-level persistent object and referenced by the TP Ref, to transient representation. More...
template<class CNV >
CNV::Trans_t *	createTransFromPStore (CNV **cnv, const TPObjRef &ref, MsgStream &log) const
	Create transient representation of a persistent object, stored in the the top-level persistent object and referenced by the TP Ref. More...
virtual void	initPrivateConverters (TopLevelTPCnvBase *)
virtual TopLevelTPCnvBase *	topConverter ()
	return the top-level converter for this elemental TP converter More...
virtual const TopLevelTPCnvBase *	topConverter () const
	return the top-level converter for this elemental TP converter More...
const std::type_info &	transBaseTInfo () const
	return C++ type id of the common base transient type for all converters for a group of polymorphic types More...
virtual const TPObjRef::typeID_t &	typeID () const
	Return TP typeID for persistent objects produced by this converter. More...
unsigned	typeIDvalue () const
	inlined non-virtual version to get the typeID value fast More...
virtual void	setRuntimeTopConverter (TopLevelTPCnvBase *topConverter)
	Set runtime top-level converter - usually it is the owning TL converter, but in case of extended objects it will be the TL converter of the extended object. More...
virtual void	setTopConverter (TopLevelTPCnvBase *topConverter, const TPObjRef::typeID_t &TPtypeID)
	Set which top-level converter owns this elemental converter, and what TPtypeID was assigned to the persistent objects it produces. More...
void	setReadingFlag ()
void	clearReadingFlag ()
bool	wasUsedForReading ()
virtual void	converterNotFound (const std::type_info &converterType, ITPConverter *c, const std::string &typeName, MsgStream &log) const
	method called when the right TP converter was not found during writing More...
virtual void	converterNotFound (unsigned typeID, ITPConverter *c, const std::string &typeName, MsgStream &log) const
	method called when the right TP converter was not found during reading More...

Protected Types
typedef std::unordered_map< HepMC::GenParticlePtr, int >	ParticlesMap_t

Protected Member Functions
HepMC::GenVertexPtr	createGenVertex (const McEventCollection_p6 &persEvts, const GenVertex_p6 &vtx, ParticlesMap_t &bcToPart, HepMC::DataPool &datapools, HepMC::GenEvent *parent=nullptr) const
	Create a transient GenVertex from a persistent one (version 1) It returns the new GenVertex. More...
HepMC::GenParticlePtr	createGenParticle (const GenParticle_p6 &p, ParticlesMap_t &partToEndVtx, HepMC::DataPool &datapools, const HepMC::GenVertexPtr &parent=nullptr, bool add_to_output=true) const
	Create a transient GenParticle from a persistent one (vers.1) It returns the new GenParticle. More...
void	writeGenVertex (const HepMC::GenVertex &vtx, McEventCollection_p6 &persEvt) const
	Method to write a persistent GenVertex object. More...
int	writeGenParticle (const HepMC::GenParticle &p, McEventCollection_p6 &persEvt) const
	Method to write a persistent GenParticle object It returns the index of the persistent GenParticle into the collection of persistent of GenParticles from the persistent GenEvent. More...

Protected Attributes
bool	m_isPileup
ServiceHandle< IHepMCWeightSvc >	m_hepMCWeightSvc
std::vector< PERS > *	m_pStorage
	the address of the storage vector for persistent representations More...
int	m_curRecLevel
	count recursive invocations, to detect recursion More...
bool	m_recursive
	if true, work in recursion-safe way (slower) More...
bool	m_ignoreRecursion
	if true, do not throw errors in case of recursion. More...
TPObjRef::typeID_t	m_pStorageTID
	TP Ref typeID for the persistent objects this converter is creating. More...
unsigned	m_pStorageTIDvalue
	m_pStorageTID converted to integer value More...
TopLevelTPCnvBase *	m_topConverter
	top level converter that owns this elemental TP converter it also holds the storage object More...
TopLevelTPCnvBase *	m_topConverterRuntime
	top level converter "owning" this TP converter at runtime (different from m_topConverter in case the top-level converter and object have extensions) More...
bool	m_wasUsedForReading
	flag set when using this converter for reading triggers search for a new converter before writing, to prevent possible use of old version More...

Private Types
typedef T_AthenaPoolTPCnvBase< McEventCollection, McEventCollection_p6 >	Base_t

Detailed Description

Definition at line 54 of file McEventCollectionCnv_p6.h.

Member Typedef Documentation

Base_t

typedef T_AthenaPoolTPCnvBase<McEventCollection, McEventCollection_p6> McEventCollectionCnv_p6::Base_t

private

Definition at line 61 of file McEventCollectionCnv_p6.h.

Factory

typedef Gaudi::PluginService::Factory<ITPCnvBase*()> ITPCnvBase::Factory

inherited

Definition at line 26 of file ITPCnvBase.h.

ParticlesMap_t

typedef std::unordered_map<HepMC::GenParticlePtr,int> McEventCollectionCnv_p6::ParticlesMap_t

protected

Definition at line 102 of file McEventCollectionCnv_p6.h.

Pers_t

typedef PERS TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::Pers_t

inherited

Definition at line 335 of file TPConverter.h.

PersBase_t

typedef PERS TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::PersBase_t

inherited

Definition at line 336 of file TPConverter.h.

PolyCnvBase_t

template<class TRANS >

typedef ITPConverterFor< TRANS > ITPConverterFor< TRANS >::PolyCnvBase_t

inherited

Definition at line 41 of file TPConverter.h.

Trans_t

typedef TRANS TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::Trans_t

inherited

Definition at line 334 of file TPConverter.h.

TransBase_t

template<class TRANS >

typedef TRANS ITPConverterFor< TRANS >::TransBase_t

inherited

Definition at line 39 of file TPConverter.h.

Constructor & Destructor Documentation

McEventCollectionCnv_p6() [1/2]

McEventCollectionCnv_p6::McEventCollectionCnv_p6

(

)

Default constructor:

Definition at line 40 of file McEventCollectionCnv_p6.cxx.

                                                 :
  Base_t( ),
  m_isPileup(false),m_hepMCWeightSvc("HepMCWeightSvc","McEventCollectionCnv_p6")
{}

McEventCollectionCnv_p6() [2/2]

McEventCollectionCnv_p6::McEventCollectionCnv_p6

(

const McEventCollectionCnv_p6 &

rhs

)

Copy constructor.

Definition at line 45 of file McEventCollectionCnv_p6.cxx.

                                                                                     :
  Base_t( rhs ),
  m_isPileup(false),m_hepMCWeightSvc("HepMCWeightSvc","McEventCollectionCnv_p6")
{}

~McEventCollectionCnv_p6()

McEventCollectionCnv_p6::~McEventCollectionCnv_p6 ( )

virtualdefault

Destructor.

Member Function Documentation

baseToPersistent()

template<class TRANS >

template<class CNV >

TPObjRef ITPConverterFor< TRANS >::baseToPersistent ( CNV **  cnv, const typename CNV::Trans_t *  transObj, MsgStream &  log  ) const

inlineinherited

Persistify bass class of a given object and store the persistent represenation in the storage vector of the top-level persistent object.

The converter is located using the transient type from the CNV parameter, not from the object itself (because we need the base type, not the actual type)

Parameters

cnv	[IN/OUT] type of this parameter decides which converter will be used. Once the converter is found, this pointer will be set so the search is done only once
transObj	[IN] transient object
log	[IN] output message stream

Returns

TPObjRef TP reference to the persistent representation stored in the storage vector of the top-level persistent object

Definition at line 97 of file TPConverter.h.

                                                                                           {
     if( !*cnv || (*cnv)->wasUsedForReading() ) {
        // don't trust the converter if it was used for reading, find again
    *cnv = converterForType( *cnv, typeid(typename CNV::Trans_t), log );
    if( !*cnv )  return TPObjRef();
        (*cnv)->clearReadingFlag();
     }
//     return (**cnv).toPersistent_impl(transObj, log); 
     return (**cnv).virt_toPersistent(transObj, log); 
  }

clearReadingFlag()

template<class TRANS >

void ITPConverterFor< TRANS >::clearReadingFlag ( )

inlineinherited

Definition at line 235 of file TPConverter.h.

{ m_wasUsedForReading = false; }

converterForRef()

template<class TRANS >

template<class CNV >

CNV* ITPConverterFor< TRANS >::converterForRef ( CNV *  cnv, const TPObjRef &  ref, MsgStream &  log  ) const

inlineinherited

Find converter for a TP type ID (passed in a TP Ref), that is or ihnerits from CNV type.

Parameters

cnv	[IN] parameter specifying the converter type
ref	[IN] TP Ref to an object for which a converter is sought
log	[IN] output message stream

Returns

CNV* pointer to the converter, if found

Definition at line 74 of file TPConverter.h.

                                                                         {
     ITPConverter *c = m_topConverterRuntime->converterForRef( ref );
     cnv = dynamic_cast<CNV*>(c);
     if( !cnv )
        this->converterNotFound( ref.typeID(), c, typeid(CNV).name(), log );
     return cnv;
  }

converterForType()

template<class TRANS >

template<class CNV >

CNV* ITPConverterFor< TRANS >::converterForType ( CNV *  cnv, const std::type_info &  t_info, MsgStream &  log  ) const

inlineinherited

Find converter for a given C++ type ID, that is or ihnerits from CNV type.

Parameters

cnv	[IN] parameter specifying the converter type
t_info	[IN] C++ type id for which a converter is sought
log	[IN] output message stream

Returns

CNV* pointer to the converter, if found

Definition at line 58 of file TPConverter.h.

                                                                                 {
     ITPConverter *c = m_topConverterRuntime->converterForType( t_info );
     cnv = dynamic_cast< CNV* >( c );
     if( !cnv )
    this->converterNotFound( typeid(CNV), c, t_info.name(), log );
     return cnv;
  }

converterNotFound() [1/2]

void ITPConverter::converterNotFound ( const std::type_info &  converterType, ITPConverter *  c, const std::string &  typeName, MsgStream &  log  ) const

virtualinherited

method called when the right TP converter was not found during writing

• useful as a debugging hook, prints a detailed error message

Parameters

converterType	[IN] converterType that was requested
c	[IN] converter that was actually found (0 if not)
typeName	[IN] the C++ type name of the type for which converter was searched for
log	[IN] output message stream

Definition at line 22 of file ITPConverter.cxx.

{
   log << MSG::ERROR << ">>>>>> in parent TP converter " << typeid(*this).name()
       << ": could not find matching TP converter for type " << typeName << endmsg;
   if( c ) {
      log << MSG::ERROR << " - found incompatible converter of type "
      << typeid(*c).name() << endmsg;
   }
   log << MSG::ERROR << "  Converter handle type was " << converterType.name() << endmsg;
   errorHandler();
}

converterNotFound() [2/2]

void ITPConverter::converterNotFound ( unsigned  typeID, ITPConverter *  c, const std::string &  typeName, MsgStream &  log  ) const

virtualinherited

method called when the right TP converter was not found during reading

• useful as a debugging hook, prints a detailed error message

Parameters

typeID	[IN] converter ID that was requested
c	[IN] converter that was actually found (0 if not)
typeName	[IN] the C++ type name of the type for which converter was searched for
log	[IN] output message stream

Definition at line 40 of file ITPConverter.cxx.

{
   log << MSG::ERROR << ">>>>>> in parent TP converter " <<  typeid(*this).name()
       << "   requested TP converter for TP type ID " << typeID << " not found " << endmsg;
   if( c ) {
      log << MSG::ERROR << " - found converter " <<  typeid(*c).name()
          << " for " << c->transientTInfo().name()
          << " with an incompatible base type " << c->transBaseTInfo().name()
          << endmsg;
   }
   log << MSG::ERROR << "  Converter handle type was " << reqCnvTypeName <<  endmsg;
   errorHandler();
}

createGenParticle()

HepMC::GenParticlePtr McEventCollectionCnv_p6::createGenParticle ( const GenParticle_p6 &  p, ParticlesMap_t &  partToEndVtx, HepMC::DataPool &  datapools, const HepMC::GenVertexPtr &  parent = nullptr, bool  add_to_output = true  ) const

protected

Create a transient GenParticle from a persistent one (vers.1) It returns the new GenParticle.

Note that the map being passed as an argument is to hold the association of barcodes to particle so that we can reconnect all the particles to their decay vertex (if any).

Definition at line 697 of file McEventCollectionCnv_p6.cxx.

{
  HepMC::GenParticlePtr p(nullptr);
    if (m_isPileup) {
    p = HepMC::newGenParticlePtr();
  } else {
    p    = datapools.getGenParticle();
  }
  if (parent) add_to_output?parent->add_particle_out(p):parent->add_particle_in(p);
#ifdef HEPMC3
  p->set_pdg_id(              persPart.m_pdgId);
  p->set_status(HepMC::new_particle_status_from_old(persPart.m_status, persPart.m_barcode)); // UPDATED STATUS VALUE TO NEW SCHEME
  p->add_attribute("phi",std::make_shared<HepMC3::DoubleAttribute>(persPart.m_phiPolarization));
  p->add_attribute("theta",std::make_shared<HepMC3::DoubleAttribute>(persPart.m_thetaPolarization));
  HepMC::suggest_barcode (p, persPart.m_barcode);
  p->set_generated_mass(persPart.m_generated_mass);
 
  // Note: do the E calculation in extended (long double) precision.
  // That happens implicitly on x86 with optimization on; saying it
  // explicitly ensures that we get the same results with and without
  // optimization.  (If this is a performance issue for platforms
  // other than x86, one could change to double for those platforms.)
  if ( 0 == persPart.m_recoMethod ) {
    double temp_e = std::sqrt( (long double)(persPart.m_px)*persPart.m_px +
                          (long double)(persPart.m_py)*persPart.m_py +
                          (long double)(persPart.m_pz)*persPart.m_pz +
                          (long double)(persPart.m_m) *persPart.m_m );
      p->set_momentum( HepMC::FourVector(persPart.m_px,persPart.m_py,persPart.m_pz,temp_e));
  } else {
    const int signM2 = ( persPart.m_m >= 0. ? 1 : -1 );
    const double persPart_ene =
      std::sqrt( std::abs((long double)(persPart.m_px)*persPart.m_px +
                (long double)(persPart.m_py)*persPart.m_py +
                (long double)(persPart.m_pz)*persPart.m_pz +
                signM2* (long double)(persPart.m_m)* persPart.m_m));
    const int signEne = ( persPart.m_recoMethod == 1 ? 1 : -1 );
    p->set_momentum(HepMC::FourVector( persPart.m_px,
                       persPart.m_py,
                       persPart.m_pz,
                       signEne * persPart_ene ));
  }
 
  // setup flow
  std::vector<int> flows;
  const unsigned int nFlow = persPart.m_flow.size();
  for ( unsigned int iFlow= 0; iFlow != nFlow; ++iFlow ) {
  flows.push_back(persPart.m_flow[iFlow].second );
  }
  //We construct it here as vector w/o gaps.
  p->add_attribute("flows", std::make_shared<HepMC3::VectorIntAttribute>(flows));
#else
  p->m_pdg_id              = persPart.m_pdgId;
  p->m_status              = HepMC::new_particle_status_from_old(persPart.m_status, persPart.m_barcode); // UPDATED STATUS VALUE TO NEW SCHEME
  p->m_polarization.m_theta= static_cast<double>(persPart.m_thetaPolarization);
  p->m_polarization.m_phi  = static_cast<double>(persPart.m_phiPolarization  );
  p->m_production_vertex   = 0;
  p->m_end_vertex          = 0;
  p->m_barcode             = persPart.m_barcode;
  p->m_generated_mass      = static_cast<double>(persPart.m_generated_mass);
 
  // Note: do the E calculation in extended (long double) precision.
  // That happens implicitly on x86 with optimization on; saying it
  // explicitly ensures that we get the same results with and without
  // optimization.  (If this is a performance issue for platforms
  // other than x86, one could change to double for those platforms.)
  if ( 0 == persPart.m_recoMethod ) {
 
    p->m_momentum.setPx( persPart.m_px);
    p->m_momentum.setPy( persPart.m_py);
    p->m_momentum.setPz( persPart.m_pz);
    double temp_e = std::sqrt( (long double)(persPart.m_px)*persPart.m_px +
                          (long double)(persPart.m_py)*persPart.m_py +
                          (long double)(persPart.m_pz)*persPart.m_pz +
                          (long double)(persPart.m_m) *persPart.m_m );
    p->m_momentum.setE( temp_e);
  } else {
    const int signM2 = ( persPart.m_m >= 0. ? 1 : -1 );
    const double persPart_ene =
      std::sqrt( std::abs((long double)(persPart.m_px)*persPart.m_px +
                (long double)(persPart.m_py)*persPart.m_py +
                (long double)(persPart.m_pz)*persPart.m_pz +
                signM2* (long double)(persPart.m_m)* persPart.m_m));
    const int signEne = ( persPart.m_recoMethod == 1 ? 1 : -1 );
    p->m_momentum.set( persPart.m_px,
                       persPart.m_py,
                       persPart.m_pz,
                       signEne * persPart_ene );
  }
 
  // setup flow
  const unsigned int nFlow = persPart.m_flow.size();
  p->m_flow.clear();
  for ( unsigned int iFlow= 0; iFlow != nFlow; ++iFlow ) {
    p->m_flow.set_icode( persPart.m_flow[iFlow].first,
                         persPart.m_flow[iFlow].second );
  }
#endif
 
  if ( persPart.m_endVtx != 0 ) {
    partToEndVtx[p] = persPart.m_endVtx;
  }
 
  return p;
}

createGenVertex()

HepMC::GenVertexPtr McEventCollectionCnv_p6::createGenVertex ( const McEventCollection_p6 &  persEvts, const GenVertex_p6 &  vtx, ParticlesMap_t &  bcToPart, HepMC::DataPool &  datapools, HepMC::GenEvent *  parent = nullptr  ) const

protected

Create a transient GenVertex from a persistent one (version 1) It returns the new GenVertex.

This method calls createGenParticle for each of the out-going particles and only for the in-going particle which are orphans (no production vertex): for optimisation purposes. Note that the map being passed as an argument is to hold the association of barcodes to particle so that we can reconnect all the (non-orphan) particles to their decay vertex (if any).

Definition at line 630 of file McEventCollectionCnv_p6.cxx.

{
  HepMC::GenVertexPtr vtx(nullptr);
  if(m_isPileup) {
    vtx=HepMC::newGenVertexPtr();
  } else {
    vtx = datapools.getGenVertex();
  }
  if (parent ) parent->add_vertex(vtx);
#ifdef HEPMC3
  vtx->set_position(HepMC::FourVector( persVtx.m_x , persVtx.m_y , persVtx.m_z ,persVtx.m_t ));
  //AV ID cannot be assigned in HepMC3. And its meaning in HepMC2 is not clear.
  vtx->set_status(HepMC::new_vertex_status_from_old(persVtx.m_id, persVtx.m_barcode)); // UPDATED STATUS VALUE TO NEW SCHEME
  // cast from std::vector<float> to std::vector<double>
  std::vector<double> weights( persVtx.m_weights.begin(), persVtx.m_weights.end() );
  vtx->add_attribute("weights",std::make_shared<HepMC3::VectorDoubleAttribute>(weights));
  HepMC::suggest_barcode (vtx, persVtx.m_barcode);
  // handle the in-going (orphans) particles
  const unsigned int nPartsIn = persVtx.m_particlesIn.size();
  for ( unsigned int i = 0; i != nPartsIn; ++i ) {
    createGenParticle( persEvt.m_genParticles[persVtx.m_particlesIn[i]], partToEndVtx, datapools, vtx, false );
  }
 
  // now handle the out-going particles
  const unsigned int nPartsOut = persVtx.m_particlesOut.size();
  for ( unsigned int i = 0; i != nPartsOut; ++i ) {
    createGenParticle( persEvt.m_genParticles[persVtx.m_particlesOut[i]], partToEndVtx, datapools, vtx );
  }
#else
  vtx->m_position.setX( persVtx.m_x );
  vtx->m_position.setY( persVtx.m_y );
  vtx->m_position.setZ( persVtx.m_z );
  vtx->m_position.setT( persVtx.m_t );
  vtx->m_particles_in.clear();
  vtx->m_particles_out.clear();
  vtx->m_id      = HepMC::new_vertex_status_from_old(persVtx.m_id, persVtx.m_barcode); // UPDATED STATUS VALUE TO NEW SCHEME
  vtx->m_weights.m_weights.reserve( persVtx.m_weights.size() );
  vtx->m_weights.m_weights.assign ( persVtx.m_weights.begin(),
                                    persVtx.m_weights.end() );
  vtx->m_event   = 0;
  vtx->m_barcode = persVtx.m_barcode;
 
  // handle the in-going (orphans) particles
  const unsigned int nPartsIn = persVtx.m_particlesIn.size();
  for ( unsigned int i = 0; i != nPartsIn; ++i ) {
    createGenParticle( persEvt.m_genParticles[persVtx.m_particlesIn[i]],
                       partToEndVtx,
                       datapools );
  }
 
  // now handle the out-going particles
  const unsigned int nPartsOut = persVtx.m_particlesOut.size();
  for ( unsigned int i = 0; i != nPartsOut; ++i ) {
    vtx->add_particle_out( createGenParticle( persEvt.m_genParticles[persVtx.m_particlesOut[i]],
                                              partToEndVtx,
                                              datapools ) );
  }
#endif
 
  return vtx;
}

createPersistent()

virtual PERS* TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::createPersistent ( const TRANS *  transObj, MsgStream &  log  )

virtualinherited

Create persistent representation of a transient object.

Simply creates a new persistent object and calls transToPers()

Parameters

transObj	[IN] transient object
log	[IN] output message stream

Returns

the created persistent representation

createPersistentWithKey()

virtual PERS* TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::createPersistentWithKey ( const TRANS *  transObj, const std::string &  key, MsgStream &  log  )

virtualinherited

Create persistent representation of a transient object, with SG key.

Simply creates a new persistent object and calls transToPersWithKey()

Parameters

transObj	[IN] transient object
key	[IN] SG key of object being written
log	[IN] output message stream

Returns

the created persistent representation

createTransFromPStore()

template<class TRANS >

template<class CNV >

CNV::Trans_t* ITPConverterFor< TRANS >::createTransFromPStore ( CNV **  cnv, const TPObjRef &  ref, MsgStream &  log  ) const

inlineinherited

Create transient representation of a persistent object, stored in the the top-level persistent object and referenced by the TP Ref.

If a TP converter is not specified, it will be found based on the Ref type.

Parameters

cnv	[IN][OUT] pointer to the converter, usually 0 at the start. Once the right converter is found, this pointer will be set so the search is done only once
ref	[IN] TP Ref to the persistent object to be converted
log	[IN] output message stream

Returns

pointer to the created transient represention

Definition at line 172 of file TPConverter.h.

                                                                               {
     if( ref.isNull() )  return 0;
     CNV *temp_cnv_p = 0;
     if( !cnv ) cnv = &temp_cnv_p;
     // see if we already have a converter and if it is the right one
     if( !*cnv || (*cnv)->typeID().value() != ref.typeID() ) {
        // we don't - find the right converter for ref.typeID()
    *cnv = converterForRef( *cnv, ref, log );
    if( !*cnv ) return 0;
        (*cnv)->setReadingFlag();
     }
     return (**cnv).virt_createTransFromPStore( ref.index(), log );
  }

createTransient()

virtual TRANS* TPPolyCnvBase< TRANS , TRANS, PERS >::createTransient ( const PERS *  persObj, MsgStream &  log  )

virtualinherited

Create transient representation of a persistent object.

Simply creates a new transient object and calls persToTrans()

Parameters

persObj	[IN] persistent object
log	[IN] output message stream

Returns

the created transient object

createTransientWithKey()

virtual TRANS* TPPolyCnvBase< TRANS , TRANS, PERS >::createTransientWithKey ( const PERS *  persObj, const std::string &  key, MsgStream &  log  )

virtualinherited

Create transient representation of a persistent object, with SG key.

Simply creates a new transient object and calls persToTransWithKey()

Parameters

persObj	[IN] persistent object
key	[IN] SG key of object being read
log	[IN] output message stream

Returns

the created transient object

fillTransFromPStore()

template<class TRANS >

template<class CNV , class TRANS_T >

void ITPConverterFor< TRANS >::fillTransFromPStore ( CNV **  cnv, const TPObjRef &  ref, TRANS_T *  trans, MsgStream &  log  ) const

inlineinherited

Convert persistent object, stored in the the top-level persistent object and referenced by the TP Ref, to transient representation.

An empty transient object to be filled in is provided. If converter is not given, it will be found based on the Ref type.

Parameters

cnv	[IN][OUT] pointer to the converter, usually 0 at the start. Once the right converter is found, this pointer will be set so the search is done only once
ref	[IN] TP Ref to the persistent object to be converted
trans	[IN] pointer to the empty transient object
log	[IN] output message stream

Definition at line 145 of file TPConverter.h.

                                                                                                    {
    if( ref.isNull() )  return;
    CNV *temp_cnv_p = 0;
    if( !cnv ) cnv = &temp_cnv_p;
    // see if we already have a converter and if it is the right one
    if( !*cnv || (*cnv)->typeID().value() != ref.typeID() ) {
       // we don't - find the right converter for ref.typeID()
       *cnv = converterForRef( *cnv, ref, log );
       if( !*cnv ) return;
       (*cnv)->setReadingFlag();
     }
    (**cnv).pstoreToTrans( ref.index(), trans, log );
  }

ignoreRecursion()

void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::ignoreRecursion ( bool  flag = false )

inlineinherited

Tell the converter to ignore recursion (do not throw errors) even when recurion is detected.

UNSAFE! use only if you are sure you preallocated enough persistent storage

Definition at line 568 of file TPConverter.h.

                                           {
     m_ignoreRecursion = flag;
  }

initPrivateConverters()

template<class TRANS >

virtual void ITPConverterFor< TRANS >::initPrivateConverters ( TopLevelTPCnvBase *  )

inlinevirtualinherited

Reimplemented in JetConverterBase< Jet_p5 >, JetConverterBase< Jet_p6 >, JetCnv_p4, TauPi0DetailsCnv_p2, TauPi0ClusterCnv_p1, TauPi0DetailsCnv_p1, TauPi0CandidateCnv_p1, TrackParticleBaseCnv_p1, TrigVertexCnv_p1, TrigVertexCnv_p2, TrigInDetTrackCollectionCnv_p1, MeasuredNeutralAtaSurfaceCnv_p1< SURFACE_CNV, ATA_SURFACE >, MeasuredNeutralAtaSurfaceCnv_p1< NeutralAtaStraightLineCnv_p1, Trk::NeutralAtaStraightLine >, MeasuredNeutralAtaSurfaceCnv_p1< NeutralAtaPlaneCnv_p1, Trk::NeutralAtaPlane >, MeasuredNeutralAtaSurfaceCnv_p1< NeutralAtaDiscCnv_p1, Trk::NeutralAtaDisc >, MeasuredNeutralAtaSurfaceCnv_p1< NeutralAtaCylinderCnv_p1, Trk::NeutralAtaCylinder >, SegmentCnv_p1, VxCandidateCnv_p1, MeasuredAtaSurfaceCnv_p1< SURFACE_CNV, ATA_SURFACE >, TrackCnv_p3, MeasuredAtaSurfaceCnv_p1< AtaDiscCnv_p1, Trk::AtaDisc >, MeasuredAtaSurfaceCnv_p1< AtaPlaneCnv_p1, Trk::AtaPlane >, MeasuredAtaSurfaceCnv_p1< AtaCylinderCnv_p1, Trk::AtaCylinder >, MeasuredAtaSurfaceCnv_p1< CurvilinearParametersCnv_p1, Trk::CurvilinearParameters >, MeasuredAtaSurfaceCnv_p1< AtaStraightLineCnv_p1, Trk::AtaStraightLine >, TrackCnv_p4, TrackParticleCnv_p2, TrackCnv_p1, TrackCnv_p2, TrackCnv_p12, V0CandidateCnv_p1, VxCandidateCnv_p2, and TrackParticleCnv_p3.

Definition at line 187 of file TPConverter.h.

{}

operator=()

McEventCollectionCnv_p6 & McEventCollectionCnv_p6::operator=

(

const McEventCollectionCnv_p6 &

rhs

)

Assignement operator.

Definition at line 51 of file McEventCollectionCnv_p6.cxx.

{
  if ( this != &rhs ) {
    Base_t::operator=( rhs );
    m_isPileup=rhs.m_isPileup;m_hepMCWeightSvc = rhs.m_hepMCWeightSvc;
  }
  return *this;
}

persistentTInfo() [1/2]

virtual const std::type_info& TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::persistentTInfo ( ) const

inlinevirtualinherited

return C++ type id of the persistent class this converter is for

Returns

std::type_info&

Definition at line 482 of file TPConverter.h.

{ return typeid(PERS); }

persistentTInfo() [2/2]

virtual const std::type_info& ITPCnvBase::persistentTInfo ( ) const

pure virtualinherited

return C++ type id of the persistent class this converter is for

Returns

std::type_info&

Implemented in TopLevelTPConverter< MAIN_CNV, TL_PERS >, TPAbstractPolyCnvBase< TRANS_BASE, TRANS, PERS >, and DummyDetElementSurfaceCnv_p1.

persToTrans() [1/2]

void McEventCollectionCnv_p6::persToTrans ( const McEventCollection_p6 *  persObj, McEventCollection *  transObj, MsgStream &  log  )

virtual

Method creating the transient representation of McEventCollection from its persistent representation McEventCollection_p6.

Definition at line 68 of file McEventCollectionCnv_p6.cxx.

{
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  msg << MSG::DEBUG << "Loading McEventCollection from persistent state..."
      << endmsg;
 
  // elements are managed by DataPool
  if (!m_isPileup) {
    transObj->clear(SG::VIEW_ELEMENTS);
  }
  HepMC::DataPool datapools;
  const unsigned int nVertices = persObj->m_genVertices.size();
  datapools.vtx.prepareToAdd(nVertices);
  const unsigned int nParts = persObj->m_genParticles.size();
  datapools.part.prepareToAdd(nParts);
  const unsigned int nEvts = persObj->m_genEvents.size();
  datapools.evt.prepareToAdd(nEvts);
 
  transObj->reserve( nEvts );
  for ( std::vector<GenEvent_p6>::const_iterator
          itr = persObj->m_genEvents.begin(),
          itrEnd = persObj->m_genEvents.end();
        itr != itrEnd;
        ++itr ) {
    const GenEvent_p6& persEvt = *itr;
    HepMC::GenEvent * genEvt(nullptr);
    if(m_isPileup) {
      genEvt = new HepMC::GenEvent();
    } else {
      genEvt        =  datapools.getGenEvent();
    }
#ifdef HEPMC3
    genEvt->add_attribute ("barcodes", std::make_shared<HepMC::GenEventBarcodes>());
    for (unsigned int i = 0; i < persEvt.m_e_attribute_id.size(); ++i) {
      if (attributes_to_ignore.count(persEvt.m_e_attribute_name[i])) continue;
      genEvt->add_attribute(persEvt.m_e_attribute_name[i], std::make_shared<HepMC3::StringAttribute>(persEvt.m_e_attribute_string[i]), persEvt.m_e_attribute_id[i]);
    }
 
    genEvt->add_attribute("signal_process_id", std::make_shared<HepMC3::IntAttribute>(persEvt.m_signalProcessId));
    genEvt->set_event_number(persEvt.m_eventNbr);
    genEvt->add_attribute("mpi", std::make_shared<HepMC3::IntAttribute>(persEvt.m_mpi));
    genEvt->add_attribute("event_scale", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_eventScale));
    genEvt->add_attribute("alphaQCD", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_alphaQCD));
    genEvt->add_attribute("alphaQED", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_alphaQED));
    genEvt->add_attribute("filterWeight", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_filterWeight));
    genEvt->add_attribute("filterHT", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_filterHT));
    genEvt->add_attribute("filterMET", std::make_shared<HepMC3::DoubleAttribute>(persEvt.m_filterMET));
    genEvt->weights()= persEvt.m_weights;
    genEvt->add_attribute("random_states", std::make_shared<HepMC3::VectorLongIntAttribute>(persEvt.m_randomStates));
 
    genEvt->set_units(static_cast<HepMC3::Units::MomentumUnit>(persEvt.m_momentumUnit),
                      static_cast<HepMC3::Units::LengthUnit>(persEvt.m_lengthUnit));
 
    //restore weight names from the dedicated svc (which was keeping them in metadata for efficiency)
    if(!genEvt->run_info()) {
       HepMC3::GenRunInfoData ri_read;
       ri_read.weight_names = m_hepMCWeightSvc->weightNameVec(ctx);
       ri_read.tool_name = std::vector<std::string>();
       ri_read.tool_version = std::vector<std::string>();
       ri_read.tool_description = std::vector<std::string>();
       ri_read.attribute_name = persEvt.m_r_attribute_name;
       ri_read.attribute_string = persEvt.m_r_attribute_string;
       auto ri = std::make_shared<HepMC3::GenRunInfo>();
       ri->read_data(ri_read);
       genEvt->set_run_info(ri);
     }
    // cross-section restore
 
    if (!persEvt.m_crossSection.empty()) {
      auto cs = std::make_shared<HepMC3::GenCrossSection>();
      const std::vector<double>& xsection = persEvt.m_crossSection;
      genEvt->set_cross_section(cs);
      if( static_cast<bool>(xsection[0]) )
        cs->set_cross_section(xsection[2],xsection[1]);
      else
        cs->set_cross_section(-1.0, -1.0);
    }
 
    // heavyIon restore
    if (!persEvt.m_heavyIon.empty()) {
      auto hi = std::make_shared<HepMC3::GenHeavyIon>();
      const std::vector<float>& hIon = persEvt.m_heavyIon;
      //AV NOTE THE ORDER
      hi->set(
         static_cast<int>(hIon[12]), // Ncoll_hard
         static_cast<int>(hIon[11]), // Npart_proj
         static_cast<int>(hIon[10]), // Npart_targ
         static_cast<int>(hIon[9]), // Ncoll
         static_cast<int>(hIon[8]), // spectator_neutrons
         static_cast<int>(hIon[7]), // spectator_protons
         static_cast<int>(hIon[6]), // N_Nwounded_collisions
         static_cast<int>(hIon[5]), // Nwounded_N_collisions
         static_cast<int>(hIon[4]), // Nwounded_Nwounded_collisions
         hIon[3],                   // impact_parameter
         hIon[2],                  // event_plane_angle
         hIon[1],                  // eccentricity
         hIon[0]         );         // sigma_inel_NN
      genEvt->set_heavy_ion(hi);
    }
 
 
 
    // pdfinfo restore
    if (!persEvt.m_pdfinfo.empty())
    {
      const std::vector<double>& pdf = persEvt.m_pdfinfo;
      HepMC3::GenPdfInfoPtr pi = std::make_shared<HepMC3::GenPdfInfo>();
      pi->set(static_cast<int>(pdf[8]), // id1
              static_cast<int>(pdf[7]), // id2
              pdf[4],                   // x1
              pdf[3],                   // x2
              pdf[2],                   // scalePDF
              pdf[1],                   // pdf1
              pdf[0],                   // pdf2
              static_cast<int>(pdf[6]), // pdf_id1
              static_cast<int>(pdf[5]));// pdf_id2
      genEvt->set_pdf_info(pi);
    }
    transObj->push_back( genEvt );
 
    // create a temporary map associating the barcode of an end-vtx to its
    // particle.
    // As not all particles are stable (d'oh!) we take 50% of the number of
    // particles as an initial size of the hash-map (to prevent re-hash)
    ParticlesMap_t partToEndVtx( (persEvt.m_particlesEnd - persEvt.m_particlesBegin)/2 );
    // This is faster than the HepMC::barcode_to_vertex
    std::map<int, HepMC::GenVertexPtr> brc_to_vertex;
 
    // create the vertices
    const unsigned int endVtx = persEvt.m_verticesEnd;
    for ( unsigned int iVtx = persEvt.m_verticesBegin; iVtx != endVtx; ++iVtx ) {
       auto vtx = createGenVertex( *persObj, persObj->m_genVertices[iVtx], partToEndVtx, datapools, genEvt );
       brc_to_vertex[persObj->m_genVertices[iVtx].m_barcode] = vtx;
    } //> end loop over vertices
 
    // set the signal process vertex
    const int sigProcVtx = persEvt.m_signalProcessVtx;
    if ( sigProcVtx != 0 && brc_to_vertex.count(sigProcVtx) ) {
      HepMC::set_signal_process_vertex(genEvt, brc_to_vertex[sigProcVtx] );
    }
 
    // connect particles to their end vertices
    for (auto & p : partToEndVtx) {
      if ( brc_to_vertex.count(p.second) ) {
        auto decayVtx = brc_to_vertex[p.second];
        decayVtx->add_particle_in( p.first );
      } else {
        msg << MSG::ERROR << "GenParticle points to null end vertex !!" << endmsg;
      }
    }
    // set the beam particles
    const int beamPart1 = persEvt.m_beamParticle1;
    const int beamPart2 = persEvt.m_beamParticle2;
    if (  beamPart1 != 0  &&  beamPart2 != 0 ) {
      genEvt->set_beam_particles(HepMC::barcode_to_particle(genEvt, beamPart1),
                                 HepMC::barcode_to_particle(genEvt, beamPart2));
    }
 
#else
    genEvt->m_signal_process_id     = persEvt.m_signalProcessId;
    genEvt->m_event_number          = persEvt.m_eventNbr;
    genEvt->m_mpi                   = persEvt.m_mpi;
    genEvt->m_event_scale           = persEvt.m_eventScale;
    genEvt->m_alphaQCD              = persEvt.m_alphaQCD;
    genEvt->m_alphaQED              = persEvt.m_alphaQED;
    genEvt->m_signal_process_vertex = 0;
    genEvt->m_beam_particle_1       = 0;
    genEvt->m_beam_particle_2       = 0;
    genEvt->m_weights               = persEvt.m_weights;
    genEvt->m_random_states         = persEvt.m_randomStates;
    genEvt->m_vertex_barcodes.clear();
    genEvt->m_particle_barcodes.clear();
    genEvt->m_momentum_unit         = static_cast<HepMC::Units::MomentumUnit>(persEvt.m_momentumUnit);
    genEvt->m_position_unit         = static_cast<HepMC::Units::LengthUnit>(persEvt.m_lengthUnit);
 
    //restore weight names from the dedicated svc (which was keeping them in metadata for efficiency)
    genEvt->m_weights.m_names = m_hepMCWeightSvc->weightNames(ctx);
 
    // cross-section restore
    if( genEvt->m_cross_section )
      delete genEvt->m_cross_section;
    genEvt->m_cross_section = 0;
 
    if (!persEvt.m_crossSection.empty()) {
      genEvt->m_cross_section = new HepMC::GenCrossSection();
      const std::vector<double>& xsection = persEvt.m_crossSection;
      if( static_cast<bool>(xsection[0]) )
        genEvt->m_cross_section->set_cross_section(xsection[2],xsection[1]);
    }
 
    // heavyIon restore
    if(genEvt->m_heavy_ion )
      delete genEvt->m_heavy_ion;
    genEvt->m_heavy_ion = 0;
    if (!persEvt.m_heavyIon.empty()) {
      const std::vector<float>& hIon = persEvt.m_heavyIon;
      genEvt->m_heavy_ion = new HepMC::HeavyIon
        (
         static_cast<int>(hIon[12]), // Ncoll_hard
         static_cast<int>(hIon[11]), // Npart_proj
         static_cast<int>(hIon[10]), // Npart_targ
         static_cast<int>(hIon[9]), // Ncoll
         static_cast<int>(hIon[8]), // spectator_neutrons
         static_cast<int>(hIon[7]), // spectator_protons
         static_cast<int>(hIon[6]), // N_Nwounded_collisions
         static_cast<int>(hIon[5]), // Nwounded_N_collisions
         static_cast<int>(hIon[4]), // Nwounded_Nwounded_collisions
         hIon[3],                   // impact_parameter
         hIon[2],                  // event_plane_angle
         hIon[1],                  // eccentricity
         hIon[0]         );         // sigma_inel_NN
    }
 
 
 
    // pdfinfo restore
    if(genEvt->m_pdf_info)
      delete genEvt->m_pdf_info;
    genEvt->m_pdf_info = 0;
    if (!persEvt.m_pdfinfo.empty()) {
      const std::vector<double>& pdf = persEvt.m_pdfinfo;
      genEvt->m_pdf_info = new HepMC::PdfInfo
        (
         static_cast<int>(pdf[8]), // id1
         static_cast<int>(pdf[7]), // id2
         pdf[4],                   // x1
         pdf[3],                   // x2
         pdf[2],                   // scalePDF
         pdf[1],                   // pdf1
         pdf[0],                   // pdf2
         static_cast<int>(pdf[6]), // pdf_id1
         static_cast<int>(pdf[5])  // pdf_id2
         );
    }
 
    transObj->push_back( genEvt );
 
    // create a temporary map associating the barcode of an end-vtx to its
    // particle.
    // As not all particles are stable (d'oh!) we take 50% of the number of
    // particles as an initial size of the hash-map (to prevent re-hash)
    ParticlesMap_t partToEndVtx( (persEvt.m_particlesEnd-
                                  persEvt.m_particlesBegin)/2 );
 
    // create the vertices
    const unsigned int endVtx = persEvt.m_verticesEnd;
    for ( unsigned int iVtx= persEvt.m_verticesBegin; iVtx != endVtx; ++iVtx ) {
      genEvt->add_vertex( createGenVertex( *persObj,
                                           persObj->m_genVertices[iVtx],
                                           partToEndVtx,
                                           datapools ) );
    } //> end loop over vertices
 
    // set the signal process vertex
    const int sigProcVtx = persEvt.m_signalProcessVtx;
    if ( sigProcVtx != 0 ) {
      genEvt->set_signal_process_vertex( genEvt->barcode_to_vertex( sigProcVtx ) );
    }
 
    // connect particles to their end vertices
    for ( ParticlesMap_t::iterator
            p = partToEndVtx.begin(),
            endItr = partToEndVtx.end();
          p != endItr;
          ++p ) {
      auto decayVtx = HepMC::barcode_to_vertex(genEvt, p->second );
      if ( decayVtx ) {
        decayVtx->add_particle_in( p->first );
      } else {
        msg << MSG::ERROR
            << "GenParticle points to null end vertex !!"
            << endmsg;
      }
    }
 
    // set the beam particles
    const int beamPart1 = persEvt.m_beamParticle1;
    const int beamPart2 = persEvt.m_beamParticle2;
    if (  beamPart1 != 0  &&  beamPart2 !=0 ) {
      genEvt->set_beam_particles(genEvt->barcode_to_particle(beamPart1),
                                 genEvt->barcode_to_particle(beamPart2));
    }
 
#endif
 
 
  } //> end loop over m_genEvents
 
  msg << MSG::DEBUG << "Loaded McEventCollection from persistent state [OK]"
      << endmsg;
}

persToTrans() [2/2]

virtual void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::persToTrans ( const PERS *  persObj, TRANS *  transObj, MsgStream &  log  )

pure virtualinherited

Convert persistent representation to transient one.

Copies data members from persistent object to an existing transient one. Needs to be implemented by the developer on the actual converter.

Parameters

persObj	[IN] persistent object
transObj	[IN] transient object
log	[IN] output message stream

Implemented in TPCnvIDContFromIdentifier< TRANS, PERS, CONV >, TPCnvIDCont< TRANS, PERS, CONV >, TPCnvStdVector< TRANS, PERS, CONV >, TPCnvVector< TRANS, PERS, CONV >, TPValVectorCnv< TRANS, PERS, CONV >, TPPtrVectorCnv< TRANS, PERS, CONV >, TPConverterConstBase< TRANS, PERS >, T_AtlasHitsVectorCnv< TRANS, PERS, CONV >, and T_AthenaHitsVectorCnv< TRANS, PERS, CONV >.

persToTransUntyped()

virtual void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::persToTransUntyped ( const void *  pers, void *  trans, MsgStream &  log  )

inlinevirtualinherited

Convert persistent object representation to transient.

Parameters

pers	[IN] void* pointer to the persistent object
trans	[OUT] void* pointer to the empty transient object
log	[IN] output message stream

Implements ITPCnvBase.

Definition at line 400 of file TPConverter.h.

  {
    persToTrans (reinterpret_cast<const PERS*> (pers),
                 reinterpret_cast<TRANS*> (trans),
                 log);
  }

persToTransWithKey()

virtual void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::persToTransWithKey ( const PERS *  persObj, TRANS *  transObj, const std::string &  , MsgStream &  log  )

inlinevirtualinherited

Convert persistent representation to transient one.

Copies data members from persistent object to an existing transient one. Needs to be implemented by the developer on the actual converter.

Parameters

persObj	[IN] persistent object
transObj	[IN] transient object
log	[IN] output message stream

Reimplemented in TPConverterWithKeyBase< TRANS, PERS >.

Definition at line 376 of file TPConverter.h.

  {
    return persToTrans (persObj, transObj, log);
  }

persToTransWithKeyUntyped()

virtual void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::persToTransWithKeyUntyped ( const void *  pers, void *  trans, const std::string &  key, MsgStream &  log  )

inlinevirtualinherited

Convert persistent object representation to transient.

Parameters

pers	[IN] void* pointer to the persistent object
trans	[OUT] void* pointer to the empty transient object
key	[IN] SG key of object being read.
log	[IN] output message stream

Reimplemented from ITPCnvBase.

Definition at line 420 of file TPConverter.h.

  {
    persToTransWithKey (reinterpret_cast<const PERS*> (pers),
                        reinterpret_cast<TRANS*> (trans),
                        key,
                        log);
  }

pstoreToTrans()

template<class TRANS , class PERS >

virtual void TPConverterBase< TRANS, PERS >::pstoreToTrans ( unsigned  index, TRANS *  trans, MsgStream &  log  )

inlinevirtualinherited

Convert persistent representation stored in the storage vector of the top-level object to transient.

Internal.

Parameters

index	[IN] index of the persistent representation in the storage vector
trans	[IN] empty transient object
log	[IN] output message stream

Reimplemented from TPAbstractPolyCnvBase< TRANS, TRANS, PERS >.

Definition at line 760 of file TPConverter.h.

                                                                              {
     assert (index < this->m_pStorage->size());
     this->persToTrans( &(*this->m_pStorage)[index], trans, log );
  }

reservePStorage()

virtual void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::reservePStorage ( size_t  size )

inlinevirtualinherited

Reserve 'size' elements for persistent storage.

Implements ITPConverter.

Definition at line 573 of file TPConverter.h.

                                               {
     m_pStorage->reserve( size );
  }

setPileup()

void McEventCollectionCnv_p6::setPileup

(

)

Definition at line 967 of file McEventCollectionCnv_p6.cxx.

                                        {
  m_isPileup = true;
}

setPStorage()

void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::setPStorage ( std::vector< PERS > *  storage )

inlineinherited

Tell this converter which storage vector it should use to store or retrieve persistent representations.

Parameters

storage

[IN] the address of the storage vector

Definition at line 551 of file TPConverter.h.

                                                  {
     m_pStorage = storage;
     m_curRecLevel = 0;
  }

setReadingFlag()

template<class TRANS >

void ITPConverterFor< TRANS >::setReadingFlag ( )

inlineinherited

Definition at line 234 of file TPConverter.h.

{ m_wasUsedForReading = true; }

setRecursive()

void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::setRecursive ( bool  flag = true )

inlineinherited

Tell the converter if it should work in recursive mode slower but it can safely handle recursion.

Definition at line 559 of file TPConverter.h.

                                       {
     m_recursive = flag;
  }

setRuntimeTopConverter()

template<class TRANS >

virtual void ITPConverterFor< TRANS >::setRuntimeTopConverter ( TopLevelTPCnvBase *  topConverter )

inlinevirtualinherited

Set runtime top-level converter - usually it is the owning TL converter, but in case of extended objects it will be the TL converter of the extended object.

Parameters

topConverter

[IN] runtime top-level converter for this converter

Implements ITPConverter.

Definition at line 215 of file TPConverter.h.

                                                                          {
     m_topConverterRuntime = topConverter;
     initPrivateConverters( topConverter );
  }

setTopConverter()

template<class TRANS >

virtual void ITPConverterFor< TRANS >::setTopConverter ( TopLevelTPCnvBase *  topConverter, const TPObjRef::typeID_t &  TPtypeID  )

inlinevirtualinherited

Set which top-level converter owns this elemental converter, and what TPtypeID was assigned to the persistent objects it produces.

Parameters

topConverter	[IN] the top-level converter owning this converter
TPtypeID	[IN] TP type id for persistent objects (used in TP refs)

Implements ITPConverter.

Definition at line 221 of file TPConverter.h.

  {
     m_topConverter = m_topConverterRuntime = topConverter;
     m_pStorageTID = TPtypeID;
     m_pStorageTIDvalue = TPtypeID.value();
     initPrivateConverters( topConverter );
  }

topConverter() [1/2]

template<class TRANS >

virtual TopLevelTPCnvBase* ITPConverterFor< TRANS >::topConverter ( )

inlinevirtualinherited

return the top-level converter for this elemental TP converter

Returns

TopLevelTPCnvBas

Reimplemented from ITPConverter.

Definition at line 191 of file TPConverter.h.

                                               {
     return m_topConverter;
  }

topConverter() [2/2]

template<class TRANS >

virtual const TopLevelTPCnvBase* ITPConverterFor< TRANS >::topConverter ( ) const

inlinevirtualinherited

return the top-level converter for this elemental TP converter

Returns

TopLevelTPCnvBas

Reimplemented from ITPConverter.

Definition at line 196 of file TPConverter.h.

                                                         {
     return m_topConverter;
  }

toPersistent()

template<class TRANS >

template<class CNV >

TPObjRef ITPConverterFor< TRANS >::toPersistent ( CNV **  cnv, const typename CNV::TransBase_t *  transObj, MsgStream &  log  ) const

inlineinherited

Persistify an object and store the persistent represenation in the storage vector of the top-level persistent object.

The correct converter is located using the actual object type.

Parameters

cnv	[IN/OUT] pointer to the converter, usually 0 at the start. Once the right converter is found, this pointer will be set so the search is done only once
transObj	[IN] transient object
log	[IN] output message stream

Returns

TPObjRef TP reference to the persistent representation stored in the storage vector of the top-level persistent object

Definition at line 119 of file TPConverter.h.

                                                                                                   {
     if( !transObj ) return TPObjRef();
     CNV *temp_cnv_p = 0;
     if( !cnv ) cnv = &temp_cnv_p;
     if( !*cnv || (*cnv)->wasUsedForReading() ) {
        // don't trust the converter if it was used for reading, find again
    *cnv = converterForType( *cnv, typeid(*transObj), log );
    if( !*cnv )  return TPObjRef();
        (*cnv)->clearReadingFlag();
     }
     return (**cnv).virt_toPersistent(transObj, log);
  }

toPersistentWithKey_impl()

TPObjRef TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::toPersistentWithKey_impl ( const TRANS *  trans, const std::string &  key, MsgStream &  log  )

inherited

Convert transient object to persistent representation.

Stores the result in the storage vector of the top-level object and returns a TP Ref to it.

Parameters

trans	[IN] transient object
key	[IN] SG key of object being converted
log	[IN] output message stream

Returns

TP reference to the persistent representation

transBaseTInfo()

template<class TRANS >

const std::type_info& ITPConverterFor< TRANS >::transBaseTInfo ( ) const

inlinevirtualinherited

return C++ type id of the common base transient type for all converters for a group of polymorphic types

Returns

std::type_info& this method is not overwritten in the subclasses like transientTInfo()

Implements ITPConverter.

Definition at line 205 of file TPConverter.h.

{ return typeid(TRANS); }

transientTInfo() [1/2]

template<class TRANS >

virtual const std::type_info& ITPConverterFor< TRANS >::transientTInfo ( ) const

inlinevirtualinherited

return C++ type id of the transient class this converter is for

Returns

std::type_info&

Implements ITPCnvBase.

Reimplemented in TPAbstractPolyCnvBase< Analysis::MuonContainer, Analysis::MuonContainer, MuonContainer_p3 >, TPAbstractPolyCnvBase< TileTrackMuFeatureContainer, TileTrackMuFeatureContainer, TileTrackMuFeatureContainer_p3 >, TPAbstractPolyCnvBase< std::vector< Analysis::TauPi0Cluster * >, std::vector< Analysis::TauPi0Cluster * >, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< IsoMuonFeatureContainer, IsoMuonFeatureContainer, IsoMuonFeatureContainer_p2 >, TPAbstractPolyCnvBase< MuonFeatureDetailsContainer, MuonFeatureDetailsContainer, MuonFeatureDetailsContainer_p2 >, TPAbstractPolyCnvBase< std::vector< Trk::VxCandidate * >, std::vector< Trk::VxCandidate * >, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< MuonFeatureContainer, MuonFeatureContainer, MuonFeatureContainer_p3 >, TPAbstractPolyCnvBase< std::vector< TrigConfAlg >, std::vector< TrigConfAlg >, std::vector< TrigConfAlg_p1 > >, TPAbstractPolyCnvBase< TrigT2MbtsBitsContainer, TrigT2MbtsBitsContainer, TrigT2MbtsBitsContainer_p3 >, TPAbstractPolyCnvBase< TrigCompositeContainer, TrigCompositeContainer, TrigCompositeContainer_p1 >, TPAbstractPolyCnvBase< LumiBlockCollection, LumiBlockCollection, LumiBlockCollection_p2 >, TPAbstractPolyCnvBase< TrigTauClusterContainer, TrigTauClusterContainer, TrigTauClusterContainer_p5 >, TPAbstractPolyCnvBase< TrigRNNOutputContainer, TrigRNNOutputContainer, TrigRNNOutputContainer_p2 >, TPAbstractPolyCnvBase< TrigRoiDescriptorCollection, TrigRoiDescriptorCollection, TrigRoiDescriptorCollection_p3 >, TPAbstractPolyCnvBase< TrigTauClusterContainer, TrigTauClusterContainer, TrigTauClusterContainer_p4 >, TPAbstractPolyCnvBase< TrigT2JetContainer, TrigT2JetContainer, TrigT2JetContainer_p3 >, TPAbstractPolyCnvBase< TrigPassBitsCollection, TrigPassBitsCollection, TrigPassBitsCollection_p1 >, TPAbstractPolyCnvBase< TrigRoiDescriptorCollection, TrigRoiDescriptorCollection, TrigRoiDescriptorCollection_p2 >, TPAbstractPolyCnvBase< std::vector< const JetTagInfoBase * >, std::vector< const JetTagInfoBase * >, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< TrigTauClusterContainer, TrigTauClusterContainer, TrigTauClusterContainer_p3 >, TPAbstractPolyCnvBase< TrigMuonEFIsolationContainer, TrigMuonEFIsolationContainer, TrigMuonEFIsolationContainer_p1 >, TPAbstractPolyCnvBase< MultiComponentStateOnSurfaceDV, MultiComponentStateOnSurfaceDV, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< RingerRingsContainer, RingerRingsContainer, RingerRingsContainer_p2 >, TPAbstractPolyCnvBase< std::vector< Trk::VxTrackAtVertex * >, std::vector< Trk::VxTrackAtVertex * >, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< std::vector< TrigMonTE >, std::vector< TrigMonTE >, std::vector< TrigMonTE_p1 > >, TPAbstractPolyCnvBase< Analysis::MuonContainer, Analysis::MuonContainer, MuonContainer_p6 >, TPAbstractPolyCnvBase< TrigMissingETContainer, TrigMissingETContainer, TrigMissingETContainer_p3 >, TPAbstractPolyCnvBase< TileHitVector, TileHitVector, TileHitVector_p1 >, TPAbstractPolyCnvBase< DataVector< eflowObject >, DataVector< eflowObject >, std::vector< eflowObject_p2 > >, TPAbstractPolyCnvBase< std::vector< TrigConfSeq >, std::vector< TrigConfSeq >, std::vector< TrigConfSeq_p1 > >, TPAbstractPolyCnvBase< TrigTrtHitCountsCollection, TrigTrtHitCountsCollection, TrigTrtHitCountsCollection_p2 >, TPAbstractPolyCnvBase< JetCollection, JetCollection, ParticleJetContainer_p1 >, TPAbstractPolyCnvBase< TrigL2BjetContainer, TrigL2BjetContainer, TrigL2BjetContainer_p3 >, TPAbstractPolyCnvBase< TrigMuonEFIsolationContainer, TrigMuonEFIsolationContainer, TrigMuonEFIsolationContainer_p2 >, TPAbstractPolyCnvBase< TrigPassFlagsCollection, TrigPassFlagsCollection, TrigPassFlagsCollection_p1 >, TPAbstractPolyCnvBase< DataVector< const Trk::MeasurementBase >, DataVector< const Trk::MeasurementBase >, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< DataVector< eflowObject >, DataVector< eflowObject >, std::vector< eflowObject_p3 > >, TPAbstractPolyCnvBase< TrigTauTracksInfoCollection, TrigTauTracksInfoCollection, TrigTauTracksInfoCollection_p2 >, TPAbstractPolyCnvBase< TrackInVertexVector, TrackInVertexVector, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< TrigTauClusterDetailsContainer, TrigTauClusterDetailsContainer, TrigTauClusterDetailsContainer_p2 >, TPAbstractPolyCnvBase< TrigEMClusterContainer, TrigEMClusterContainer, TrigEMClusterContainer_p4 >, TPAbstractPolyCnvBase< std::vector< Analysis::TauShot * >, std::vector< Analysis::TauShot * >, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< DataVector< eflowObject >, DataVector< eflowObject >, std::vector< eflowObject_p4 > >, TPAbstractPolyCnvBase< std::vector< TrigMonRoi >, std::vector< TrigMonRoi >, std::vector< TrigMonRoi_p1 > >, TPAbstractPolyCnvBase< DataVector< eflowObject >, DataVector< eflowObject >, std::vector< eflowObject_p5 > >, TPAbstractPolyCnvBase< TrigTauContainer, TrigTauContainer, TrigTauContainer_p3 >, TPAbstractPolyCnvBase< TrigEMClusterContainer, TrigEMClusterContainer, TrigEMClusterContainer_p3 >, TPAbstractPolyCnvBase< TrigMuonEFContainer, TrigMuonEFContainer, TrigMuonEFContainer_p2 >, TPAbstractPolyCnvBase< ElectronMuonTopoInfoContainer, ElectronMuonTopoInfoContainer, ElectronMuonTopoInfoContainer_p1 >, TPAbstractPolyCnvBase< TrigInDetTrackCollection, TrigInDetTrackCollection, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< std::vector< const Trk::TrackParameters * >, std::vector< const Trk::TrackParameters * >, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< EventBookkeeperCollection, EventBookkeeperCollection, EventBookkeeperCollection_p2 >, TPAbstractPolyCnvBase< SkimDecisionCollection, SkimDecisionCollection, SkimDecisionCollection_p1 >, TPAbstractPolyCnvBase< std::vector< TrigConfChain >, std::vector< TrigConfChain >, std::vector< TrigConfChain_p1 > >, TPAbstractPolyCnvBase< Trk::TrackStates, Trk::TrackStates, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< CombinedMuonFeatureContainer, CombinedMuonFeatureContainer, CombinedMuonFeatureContainer_p4 >, TPAbstractPolyCnvBase< TrigPhotonContainer, TrigPhotonContainer, TrigPhotonContainer_p3 >, TPAbstractPolyCnvBase< std::vector< TrigMonSeq >, std::vector< TrigMonSeq >, std::vector< TrigMonSeq_p1 > >, TPAbstractPolyCnvBase< EventBookkeeperCollection, EventBookkeeperCollection, EventBookkeeperCollection_p1 >, TPAbstractPolyCnvBase< std::vector< TrigMonAlg >, std::vector< TrigMonAlg >, std::vector< TrigMonAlg_p1 > >, TPAbstractPolyCnvBase< CombinedMuonFeatureContainer, CombinedMuonFeatureContainer, CombinedMuonFeatureContainer_p3 >, TPAbstractPolyCnvBase< DataVector< eflowObject >, DataVector< eflowObject >, std::vector< eflowObject_p1 > >, TPAbstractPolyCnvBase< std::vector< Analysis::TauPi0Candidate * >, std::vector< Analysis::TauPi0Candidate * >, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< CombinedMuonFeatureContainer, CombinedMuonFeatureContainer, CombinedMuonFeatureContainer_p2 >, TPAbstractPolyCnvBase< TrigElectronContainer, TrigElectronContainer, TrigElectronContainer_p3 >, TPAbstractPolyCnvBase< TrigSpacePointCountsCollection, TrigSpacePointCountsCollection, TrigSpacePointCountsCollection_p4 >, TPAbstractPolyCnvBase< Analysis::MuonContainer, Analysis::MuonContainer, MuonContainer_p5 >, TPAbstractPolyCnvBase< TileMuFeatureContainer, TileMuFeatureContainer, TileMuFeatureContainer_p2 >, TPAbstractPolyCnvBase< std::vector< TrigConfSig >, std::vector< TrigConfSig >, std::vector< TrigConfSig_p1 > >, TPAbstractPolyCnvBase< std::vector< TrigMonROBData >, std::vector< TrigMonROBData >, std::vector< TrigMonROBData_p1 > >, TPAbstractPolyCnvBase< Analysis::MuonContainer, Analysis::MuonContainer, MuonContainer_p4 >, TPAbstractPolyCnvBase< LumiBlockCollection, LumiBlockCollection, LumiBlockCollection_p1 >, TPAbstractPolyCnvBase< std::vector< const JetAssociationBase * >, std::vector< const JetAssociationBase * >, std::vector< TPObjRef > >, TPAbstractPolyCnvBase< IsoMuonFeatureContainer, IsoMuonFeatureContainer, IsoMuonFeatureContainer_p3 >, TPAbstractPolyCnvBase< TrigCaloClusterContainer, TrigCaloClusterContainer, TrigCaloClusterContainer_p3 >, and TPAbstractPolyCnvBase< std::vector< TrigMonROB >, std::vector< TrigMonROB >, std::vector< TrigMonROB_p1 > >.

Definition at line 201 of file TPConverter.h.

{ return typeid(TRANS); }

transientTInfo() [2/2]

virtual const std::type_info& TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::transientTInfo ( ) const

inlinevirtualinherited

return C++ type id of the transient class this converter is for

Returns

std::type_info&

Definition at line 479 of file TPConverter.h.

{ return typeid(TRANS); }

transToPers() [1/2]

void McEventCollectionCnv_p6::transToPers ( const McEventCollection *  transObj, McEventCollection_p6 *  persObj, MsgStream &  log  )

virtual

Method creating the persistent representation McEventCollection_p6 from its transient representation McEventCollection.

Definition at line 364 of file McEventCollectionCnv_p6.cxx.

{
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  msg << MSG::DEBUG << "Creating persistent state of McEventCollection..."
      << endmsg;
  persObj->m_genEvents.reserve( transObj->size() );
 
  const std::pair<unsigned int,unsigned int> stats = nbrParticlesAndVertices( transObj );
  persObj->m_genParticles.reserve( stats.first  );
  persObj->m_genVertices.reserve ( stats.second );
 
  const McEventCollection::const_iterator itrEnd = transObj->end();
  for ( McEventCollection::const_iterator itr = transObj->begin();
        itr != itrEnd;
        ++itr ) {
    const unsigned int nPersVtx   = persObj->m_genVertices.size();
    const unsigned int nPersParts = persObj->m_genParticles.size();
    const HepMC::GenEvent* genEvt = *itr;
#ifdef HEPMC3
   //save the weight names to metadata via the HepMCWeightSvc
      auto ri = genEvt->run_info();
      HepMC3::GenRunInfoData ri_data;
      if (ri) {
        ri->write_data(ri_data);
        if (!ri_data.weight_names.empty()) {
          m_hepMCWeightSvc->setWeightNames(  names_to_name_index_map(ri_data.weight_names), ctx ).ignore();
        } else {
          //AV : This to be decided if one would like to have default names.
          //std::vector<std::string> names{"0"};
          //m_hepMCWeightSvc->setWeightNames( names_to_name_index_map(names), ctx );
        }
      }
 
      auto A_mpi=genEvt->attribute<HepMC3::IntAttribute>("mpi");
      auto A_signal_process_id=genEvt->attribute<HepMC3::IntAttribute>("signal_process_id");
      auto A_event_scale=genEvt->attribute<HepMC3::DoubleAttribute>("event_scale");
      auto A_alphaQCD=genEvt->attribute<HepMC3::DoubleAttribute>("alphaQCD");
      auto A_alphaQED=genEvt->attribute<HepMC3::DoubleAttribute>("alphaQED");
      auto A_filterWeight=genEvt->attribute<HepMC3::DoubleAttribute>("filterWeight");
      auto A_filterHT=genEvt->attribute<HepMC3::DoubleAttribute>("filterHT");
      auto A_filterMET=genEvt->attribute<HepMC3::DoubleAttribute>("filterMET");
      auto signal_process_vertex = HepMC::signal_process_vertex(genEvt);
      auto A_random_states=genEvt->attribute<HepMC3::VectorLongIntAttribute>("random_states");
      auto beams=genEvt->beams();
      persObj->m_genEvents.
      emplace_back(A_signal_process_id?(A_signal_process_id->value()):-1,
                              genEvt->event_number(),
                              A_mpi?(A_mpi->value()):-1,
                              A_event_scale?(A_event_scale->value()):0.0,
                              A_alphaQCD?(A_alphaQCD->value()):0.0,
                              A_alphaQED?(A_alphaQED->value()):0.0,
                              A_filterWeight?(A_filterWeight->value()):1.0,
                              A_filterHT?(A_filterHT->value()):-13.,
                              A_filterMET?(A_filterMET->value()):-13.0,
                              signal_process_vertex?HepMC::barcode(signal_process_vertex):0,
                              !beams.empty()?HepMC::barcode(beams[0]):0,
                              beams.size()>1?HepMC::barcode(beams[1]):0,
                              genEvt->weights(),
                              A_random_states?(A_random_states->value()):std::vector<long>(),
                              std::vector<double>(),      // cross section
                              std::vector<float>(),       // heavyion
                              std::vector<double>(),      // pdf info
                              genEvt->momentum_unit(),
                              genEvt->length_unit(),
                              nPersVtx,
                              nPersVtx + genEvt->vertices().size(),
                              nPersParts,
                              nPersParts + genEvt->particles().size() );
    {
     GenEvent_p6& persEvt = persObj->m_genEvents.back();
     std::map< std::string, std::map<int, std::shared_ptr<HepMC3::Attribute> > > e_atts = genEvt->attributes();
     persEvt.m_e_attribute_name.clear();
     persEvt.m_e_attribute_id.clear();
     persEvt.m_e_attribute_string.clear();
     for (auto& attmap: e_atts) {
       if (attributes_to_ignore.count(attmap.first)) continue;
       if (attmap.first == "ShadowParticle") continue;
       if (attmap.first == "ShadowParticleId") continue;
       for (auto& att: attmap.second) {
         persEvt.m_e_attribute_name.push_back(attmap.first);
         persEvt.m_e_attribute_id.push_back(att.first);
         std::string st;
         att.second->to_string(st);
         persEvt.m_e_attribute_string.push_back(st);
       }
     }
     persEvt.m_r_attribute_name.clear();
     persEvt.m_r_attribute_string.clear();
     if (ri) {
       persEvt.m_r_attribute_string = std::move(ri_data.attribute_string);
       persEvt.m_r_attribute_name = std::move(ri_data.attribute_name);
       /*** This is for the future
       persEvt.m_r_tool_name = ri_data.tool_name;
       persEvt.m_r_tool_version = ri_data.tool_version;
       persEvt.m_r_tool_description = ri_data.tool_description;
       */ 
     } 
    //Actually, with this piece there is no need to treat the CS and HI separately.
    }
    //HepMC::GenCrossSection encoding
    if (genEvt->cross_section()) {
      auto cs=genEvt->cross_section();
      GenEvent_p6& persEvt = persObj->m_genEvents.back();
      std::vector<double>& crossSection = persEvt.m_crossSection;
      crossSection.resize(3);
      crossSection[2] = cs->xsec();
      crossSection[1] = cs->xsec_err();
      crossSection[0] = static_cast<double>(cs->is_valid());
      if (crossSection[2] < 0) {
       crossSection[2] = 0.0;
       if (crossSection[1] < 0) {
         crossSection[1] = 0.0;
       }
       crossSection[0] = 0.0;
      }
 
    }
 
    //HepMC::HeavyIon encoding
    if (genEvt->heavy_ion()) {
      auto hi=genEvt->heavy_ion();
      GenEvent_p6& persEvt = persObj->m_genEvents.back();
      std::vector<float>& heavyIon = persEvt.m_heavyIon;
      heavyIon.resize(13);
      heavyIon[12]  = static_cast<float>(hi->Ncoll_hard);
      heavyIon[11]  = static_cast<float>(hi->Npart_proj);
      heavyIon[10]  = static_cast<float>(hi->Npart_targ);
      heavyIon[9]   = static_cast<float>(hi->Ncoll);
      heavyIon[8]   = static_cast<float>(hi->spectator_neutrons);
      heavyIon[7]   = static_cast<float>(hi->spectator_protons);
      heavyIon[6]   = static_cast<float>(hi->N_Nwounded_collisions);
      heavyIon[5]   = static_cast<float>(hi->Nwounded_N_collisions);
      heavyIon[4]   = static_cast<float>(hi->Nwounded_Nwounded_collisions);
      heavyIon[3]   = hi->impact_parameter;
      heavyIon[2]   = hi->event_plane_angle;
      heavyIon[1]   = hi->eccentricity;
      heavyIon[0]   = hi->sigma_inel_NN;
    }
 
    //PdfInfo encoding
    if (genEvt->pdf_info()) {
      auto pi=genEvt->pdf_info();
      GenEvent_p6& persEvt = persObj->m_genEvents.back();
      std::vector<double>& pdfinfo = persEvt.m_pdfinfo;
      pdfinfo.resize(9);
      pdfinfo[8] = static_cast<double>(pi->parton_id[0]);
      pdfinfo[7] = static_cast<double>(pi->parton_id[1]);
      pdfinfo[6] = static_cast<double>(pi->pdf_id[0]);
      pdfinfo[5] = static_cast<double>(pi->pdf_id[1]);
      pdfinfo[4] = pi->x[0];
      pdfinfo[3] = pi->x[1];
      pdfinfo[2] = pi->scale;
      pdfinfo[1] = pi->xf[0];
      pdfinfo[0] = pi->xf[1];
    }
 
    // create vertices
    for (const auto& v: genEvt->vertices()) {
      writeGenVertex( v, *persObj );
    }
#else
    const int signalProcessVtx = genEvt->m_signal_process_vertex
      ? genEvt->m_signal_process_vertex->barcode()
      : 0;
    const int beamParticle1Barcode = genEvt->m_beam_particle_1
      ? genEvt->m_beam_particle_1->barcode()
      : 0;
    const int beamParticle2Barcode = genEvt->m_beam_particle_2
      ? genEvt->m_beam_particle_2->barcode()
      : 0;
 
   //save the weight names to metadata via the HepMCWeightSvc
   m_hepMCWeightSvc->setWeightNames( genEvt->m_weights.m_names, ctx ).ignore();
 
 
    persObj->m_genEvents.
      push_back( GenEvent_p6( genEvt->m_signal_process_id,
                              genEvt->m_event_number,
                              genEvt->mpi(),              // number of multi particle interactions
                              genEvt->m_event_scale,
                              genEvt->m_alphaQCD,
                              genEvt->m_alphaQED,
                              1, // dummy value as this does not exist in HepMC2::GenEvent
                              signalProcessVtx,
                              beamParticle1Barcode,       // barcodes of beam particles
                              beamParticle2Barcode,
                              genEvt->m_weights.m_weights,
                              genEvt->m_random_states,
                              std::vector<double>(),      // cross section
                              std::vector<float>(),       // heavyion
                              std::vector<double>(),      // pdf info
                              genEvt->m_momentum_unit,
                              genEvt->m_position_unit,
                              nPersVtx,
                              nPersVtx + genEvt->vertices_size(),
                              nPersParts,
                              nPersParts + genEvt->particles_size() ) );
    //HepMC::GenCrossSection encoding
    if (genEvt->m_cross_section) {
      GenEvent_p6& persEvt = persObj->m_genEvents.back();
      std::vector<double>& crossSection = persEvt.m_crossSection;
      crossSection.resize(3);
      crossSection[2] = genEvt->m_cross_section->m_cross_section;
      crossSection[1] = genEvt->m_cross_section->m_cross_section_error;
      crossSection[0] = static_cast<double>(genEvt->m_cross_section->m_is_set);
    }
 
    //HepMC::HeavyIon encoding
    if (genEvt->m_heavy_ion) {
      GenEvent_p6& persEvt = persObj->m_genEvents.back();
      std::vector<float>& heavyIon = persEvt.m_heavyIon;
      heavyIon.resize(13);
      heavyIon[12]  = static_cast<float>(genEvt->m_heavy_ion->m_Ncoll_hard);
      heavyIon[11]  = static_cast<float>(genEvt->m_heavy_ion->m_Npart_proj);
      heavyIon[10]  = static_cast<float>(genEvt->m_heavy_ion->m_Npart_targ);
      heavyIon[9]   = static_cast<float>(genEvt->m_heavy_ion->m_Ncoll);
      heavyIon[8]   = static_cast<float>(genEvt->m_heavy_ion->m_spectator_neutrons);
      heavyIon[7]   = static_cast<float>(genEvt->m_heavy_ion->m_spectator_protons);
      heavyIon[6]   = static_cast<float>(genEvt->m_heavy_ion->m_N_Nwounded_collisions);
      heavyIon[5]   = static_cast<float>(genEvt->m_heavy_ion->m_Nwounded_N_collisions);
      heavyIon[4]   = static_cast<float>(genEvt->m_heavy_ion->m_Nwounded_Nwounded_collisions);
      heavyIon[3]   = genEvt->m_heavy_ion->m_impact_parameter;
      heavyIon[2]   = genEvt->m_heavy_ion->m_event_plane_angle;
      heavyIon[1]   = genEvt->m_heavy_ion->m_eccentricity;
      heavyIon[0]   = genEvt->m_heavy_ion->m_sigma_inel_NN;
    }
 
    //PdfInfo encoding
    if (genEvt->m_pdf_info) {
      GenEvent_p6& persEvt = persObj->m_genEvents.back();
      std::vector<double>& pdfinfo = persEvt.m_pdfinfo;
      pdfinfo.resize(9);
      pdfinfo[8] = static_cast<double>(genEvt->m_pdf_info->m_id1);
      pdfinfo[7] = static_cast<double>(genEvt->m_pdf_info->m_id2);
      pdfinfo[6] = static_cast<double>(genEvt->m_pdf_info->m_pdf_id1);
      pdfinfo[5] = static_cast<double>(genEvt->m_pdf_info->m_pdf_id2);
      pdfinfo[4] = genEvt->m_pdf_info->m_x1;
      pdfinfo[3] = genEvt->m_pdf_info->m_x2;
      pdfinfo[2] = genEvt->m_pdf_info->m_scalePDF;
      pdfinfo[1] = genEvt->m_pdf_info->m_pdf1;
      pdfinfo[0] = genEvt->m_pdf_info->m_pdf2;
    }
 
    // create vertices
    const HepMC::GenEvent::vertex_const_iterator endVtx=genEvt->vertices_end();
    for ( HepMC::GenEvent::vertex_const_iterator i = genEvt->vertices_begin();
          i != endVtx;
          ++i ) {
      writeGenVertex( **i, *persObj );
    }
#endif
 
  } //> end loop over GenEvents
 
  msg << MSG::DEBUG << "Created persistent state of HepMC::GenEvent [OK]" << endmsg;
}

transToPers() [2/2]

virtual void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::transToPers ( const TRANS *  transObj, PERS *  persObj, MsgStream &  log  )

pure virtualinherited

Convert transient representation to persistent one.

Copies data members from transient object to an existing persistent one. Needs to be implemented by the developer on the actual converter.

Parameters

transObj	[IN] transient object
persObj	[IN] persistent object
log	[IN] output message stream

Implemented in TPCnvIDContFromIdentifier< TRANS, PERS, CONV >, TPCnvIDCont< TRANS, PERS, CONV >, TPCnvStdVector< TRANS, PERS, CONV >, TPCnvVector< TRANS, PERS, CONV >, TPValVectorCnv< TRANS, PERS, CONV >, TPPolyVectorCnv< TRANS, PERS, CONV >, TPPtrVectorCnv< TRANS, PERS, CONV >, TPConverterConstBase< TRANS, PERS >, T_AtlasHitsVectorCnv< TRANS, PERS, CONV >, and T_AthenaHitsVectorCnv< TRANS, PERS, CONV >.

transToPersUntyped()

virtual void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::transToPersUntyped ( const void *  trans, void *  pers, MsgStream &  log  )

inlinevirtualinherited

Convert transient object representation to persistent.

Parameters

trans	[IN] void* pointer to the transient object
pers	[OUT] void* pointer to the empty persistent object
log	[IN] output message stream

Implements ITPCnvBase.

Definition at line 410 of file TPConverter.h.

  {
    transToPers (reinterpret_cast<const TRANS*> (trans),
                 reinterpret_cast<PERS*> (pers),
                 log);
  }

transToPersWithKey()

virtual void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::transToPersWithKey ( const TRANS *  transObj, PERS *  persObj, const std::string &  , MsgStream &  log  )

inlinevirtualinherited

Convert transient representation to persistent one.

Copies data members from transient object to an existing persistent one. Needs to be implemented by the developer on the actual converter.

Parameters

transObj	[IN] transient object
persObj	[IN] persistent object
key	[IN] SG key of object being written.
log	[IN] output message stream

Reimplemented in TPConverterWithKeyBase< TRANS, PERS >.

Definition at line 392 of file TPConverter.h.

  {
    return transToPers (transObj, persObj, log);
  }

transToPersWithKeyUntyped()

virtual void TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::transToPersWithKeyUntyped ( const void *  trans, void *  pers, const std::string &  key, MsgStream &  log  )

inlinevirtualinherited

Convert transient object representation to persistent.

Parameters

trans	[IN] void* pointer to the transient object
pers	[OUT] void* pointer to the empty persistent object
key	[IN] SG key of object being written.
log	[IN] output message stream

Reimplemented from ITPCnvBase.

Definition at line 432 of file TPConverter.h.

  {
    transToPersWithKey (reinterpret_cast<const TRANS*> (trans),
                        reinterpret_cast<PERS*> (pers),
                        key,
                        log);
  }

typeID()

template<class TRANS >

virtual const TPObjRef::typeID_t& ITPConverterFor< TRANS >::typeID ( ) const

inlinevirtualinherited

Return TP typeID for persistent objects produced by this converter.

Returns

TPObjRef::typeID_t&

Implements ITPConverter.

Definition at line 208 of file TPConverter.h.

{ return m_pStorageTID; }

typeIDvalue()

template<class TRANS >

unsigned ITPConverterFor< TRANS >::typeIDvalue ( ) const

inlineinherited

inlined non-virtual version to get the typeID value fast

Definition at line 211 of file TPConverter.h.

{ return m_pStorageTIDvalue; }

virt_createTransFromPStore()

virtual TRANS* TPPolyCnvBase< TRANS , TRANS, PERS >::virt_createTransFromPStore ( unsigned  index, MsgStream &  log  )

inlinevirtualinherited

Internal interface method that is used to invoke the real conversion method (createTransient)

Parameters

index	[IN] index of the persistent object in the storage vector
log	[IN] output message stream

Returns

Created transient object (by pointer)

Reimplemented from TPAbstractPolyCnvBase< TRANS, TRANS, PERS >.

Definition at line 706 of file TPConverter.h.

                                                                               {
     assert (index < this->m_pStorage->size());
     return createTransient( &(*this->m_pStorage)[index], log );
  }

virt_createTransFromPStoreWithKey()

virtual TRANS* TPPolyCnvBase< TRANS , TRANS, PERS >::virt_createTransFromPStoreWithKey ( unsigned  index, const std::string &  key, MsgStream &  log  )

inlinevirtualinherited

Internal interface method that is used to invoke the real conversion method (createTransient)

Parameters

index	[IN] index of the persistent object in the storage vector
key	[IN] SG key of the object being converted
log	[IN] output message stream

Returns

Created transient object (by pointer)

Reimplemented from TPAbstractPolyCnvBase< TRANS, TRANS, PERS >.

Definition at line 718 of file TPConverter.h.

  {
     assert (index < this->m_pStorage->size());
     return createTransientWithKey( &(*this->m_pStorage)[index], key, log );
  }

virt_toPersistent()

template<class TRANS , class PERS >

virtual TPObjRef TPConverterBase< TRANS, PERS >::virt_toPersistent ( const TRANS *  trans, MsgStream &  log  )

inlinevirtualinherited

Internal interface method that is used to invoke the real conversion method (toPersistent_impl) in the derived converter.

Parameters

trans	[IN] transient object
log	[IN] output message stream

Returns

TPObjRef TP reference to the persistent representation stored in the storage vector of the top-level persistent object Here toPersistent_impl is invoked with the dynamic cast of the transient type pointer to it's actual type

Reimplemented from TPAbstractPolyCnvBase< TRANS, TRANS, PERS >.

Definition at line 747 of file TPConverter.h.

                                                                           {
    return this->toPersistentWithKey_impl( trans, "", log);
  }

virt_toPersistentWithKey()

template<class TRANS , class PERS >

virtual TPObjRef TPConverterBase< TRANS, PERS >::virt_toPersistentWithKey ( const TRANS *  trans, const std::string &  key, MsgStream &  log  )

inlinevirtualinherited

Internal interface method that is used to invoke the real conversion method (toPersistent_impl) in the derived converter.

Parameters

trans	[IN] transient object
key	[IN] SG key of the object being converted.
log	[IN] output message stream

Returns

TPObjRef TP reference to the persistent representation stored in the storage vector of the top-level persistent object Here toPersistentWithKey_impl is invoked with the dynamic cast of the transient type pointer to it's actual type

Reimplemented from TPAbstractPolyCnvBase< TRANS, TRANS, PERS >.

Definition at line 752 of file TPConverter.h.

  {
     return this->toPersistentWithKey_impl( trans, key, log);
  }

wasUsedForReading()

template<class TRANS >

bool ITPConverterFor< TRANS >::wasUsedForReading ( )

inlineinherited

Definition at line 236 of file TPConverter.h.

{ return m_wasUsedForReading; }

writeGenParticle()

int McEventCollectionCnv_p6::writeGenParticle ( const HepMC::GenParticle &  p, McEventCollection_p6 &  persEvt  ) const

protected

Method to write a persistent GenParticle object It returns the index of the persistent GenParticle into the collection of persistent of GenParticles from the persistent GenEvent.

Definition at line 921 of file McEventCollectionCnv_p6.cxx.

{
  const HepMC::FourVector& mom = p.m_momentum;
  const double ene = mom.e();
  const double m2  = mom.m2();
 
  // Definitions of Bool isTimeLilike, isSpacelike and isLightlike according to HepLorentzVector definition
  const bool useP2M2 = !(m2 > 0) &&   // !isTimelike
    (m2 < 0) &&   //  isSpacelike
    !(std::abs(m2) < 2.0*DBL_EPSILON*ene*ene); // !isLightlike
 
  const short recoMethod = ( !useP2M2
                             ? 0
                             : ( ene >= 0. //*GeV
                                 ? 1
                                 : 2 ) );
 
  persEvt.m_genParticles.
    push_back( GenParticle_p6( mom.px(),
                               mom.py(),
                               mom.pz(),
                               mom.m(),
                               p.m_pdg_id,
                               HepMC::old_particle_status_from_new(p.m_status), // REVERTED STATUS VALUE TO OLD SCHEME
                               p.m_flow.size(),
                               p.m_polarization.theta(),
                               p.m_polarization.phi(),
                               p.m_production_vertex
                               ? p.m_production_vertex->barcode()
                               : 0,
                               p.m_end_vertex
                               ? p.m_end_vertex->barcode()
                               : 0,
                               p.m_barcode,
                               p.m_generated_mass,
                               recoMethod ) );
  persEvt.m_genParticles.back().m_flow.assign( p.m_flow.begin(),
                                               p.m_flow.end() );
 
  // we return the index of the particle in the big vector of particles
  // (contained by the persistent GenEvent)
  return (persEvt.m_genParticles.size() - 1);
}

writeGenVertex()

void McEventCollectionCnv_p6::writeGenVertex ( const HepMC::GenVertex &  vtx, McEventCollection_p6 &  persEvt  ) const

protected

Method to write a persistent GenVertex object.

The persistent vertex is added to the persistent is added to the persistent GenEvent.

Definition at line 840 of file McEventCollectionCnv_p6.cxx.

{
  const HepMC::FourVector& position = vtx.m_position;
  persEvt.m_genVertices.push_back(
                                  GenVertex_p6( position.x(),
                                                position.y(),
                                                position.z(),
                                                position.t(),
                                                HepMC::old_vertex_status_from_new(vtx.m_id), // REVERTED STATUS VALUE TO OLD SCHEME
                                                vtx.m_weights.m_weights.begin(),
                                                vtx.m_weights.m_weights.end(),
                                                vtx.m_barcode ) );
  GenVertex_p6& persVtx = persEvt.m_genVertices.back();
 
  // we write only the orphans in-coming particles
  const std::vector<HepMC::GenParticlePtr>::const_iterator endInVtx = vtx.m_particles_in.end();
  persVtx.m_particlesIn.reserve(vtx.m_particles_in.size());
  for ( std::vector<HepMC::GenParticlePtr>::const_iterator p = vtx.m_particles_in.begin();
        p != endInVtx;
        ++p ) {
    if ( 0 == (*p)->production_vertex() ) {
      persVtx.m_particlesIn.push_back( writeGenParticle( **p, persEvt ) );
    }
  }
 
  const std::vector<HepMC::GenParticlePtr>::const_iterator endOutVtx = vtx.m_particles_out.end();
  persVtx.m_particlesOut.reserve(vtx.m_particles_out.size());
  for ( std::vector<HepMC::GenParticlePtr>::const_iterator p = vtx.m_particles_out.begin();
        p != endOutVtx;
        ++p ) {
    persVtx.m_particlesOut.push_back( writeGenParticle( **p, persEvt ) );
  }
 
  return;
}

Member Data Documentation

m_curRecLevel

int TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::m_curRecLevel

protectedinherited

count recursive invocations, to detect recursion

Definition at line 582 of file TPConverter.h.

m_hepMCWeightSvc

ServiceHandle<IHepMCWeightSvc> McEventCollectionCnv_p6::m_hepMCWeightSvc

protected

Definition at line 151 of file McEventCollectionCnv_p6.h.

m_ignoreRecursion

bool TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::m_ignoreRecursion

protectedinherited

if true, do not throw errors in case of recursion.

Definition at line 588 of file TPConverter.h.

m_isPileup

bool McEventCollectionCnv_p6::m_isPileup

protected

Definition at line 150 of file McEventCollectionCnv_p6.h.

m_pStorage

std::vector< PERS >* TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::m_pStorage

protectedinherited

the address of the storage vector for persistent representations

Definition at line 579 of file TPConverter.h.

m_pStorageTID

template<class TRANS >

TPObjRef::typeID_t ITPConverterFor< TRANS >::m_pStorageTID

protectedinherited

TP Ref typeID for the persistent objects this converter is creating.

Definition at line 292 of file TPConverter.h.

m_pStorageTIDvalue

template<class TRANS >

unsigned ITPConverterFor< TRANS >::m_pStorageTIDvalue

protectedinherited

m_pStorageTID converted to integer value

Definition at line 295 of file TPConverter.h.

m_recursive

bool TPAbstractPolyCnvBase< TRANS , TRANS, PERS >::m_recursive

protectedinherited

if true, work in recursion-safe way (slower)

Definition at line 585 of file TPConverter.h.

m_topConverter

template<class TRANS >

TopLevelTPCnvBase* ITPConverterFor< TRANS >::m_topConverter

protectedinherited

top level converter that owns this elemental TP converter it also holds the storage object

Definition at line 299 of file TPConverter.h.

m_topConverterRuntime

template<class TRANS >

TopLevelTPCnvBase* ITPConverterFor< TRANS >::m_topConverterRuntime

protectedinherited

top level converter "owning" this TP converter at runtime (different from m_topConverter in case the top-level converter and object have extensions)

Definition at line 302 of file TPConverter.h.

m_wasUsedForReading

template<class TRANS >

bool ITPConverterFor< TRANS >::m_wasUsedForReading

protectedinherited

flag set when using this converter for reading triggers search for a new converter before writing, to prevent possible use of old version

Definition at line 306 of file TPConverter.h.

---

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

• McEventCollectionCnv_p6.h
• McEventCollectionCnv_p6.cxx