#include <HadronizerFilter.h>

Inheritance diagram for edm::HadronizerFilter< HAD, DEC >:

Public Types
typedef DEC	Decayer

typedef HAD	Hadronizer

Public Types inherited from edm::one::EDFilterBase
typedef EDFilterBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
void	beginLuminosityBlock (LuminosityBlock const &, EventSetup const &) override

void	beginLuminosityBlockProduce (LuminosityBlock &, EventSetup const &) override

void	beginRun (Run const &, EventSetup const &) override

void	endLuminosityBlock (LuminosityBlock const &, EventSetup const &) override

void	endLuminosityBlockProduce (LuminosityBlock &, EventSetup const &) override

void	endRun (Run const &, EventSetup const &) override

void	endRunProduce (Run &, EventSetup const &) override

bool	filter (Event &e, EventSetup const &es) override

	HadronizerFilter (ParameterSet const &ps)

	~HadronizerFilter () override

Public Member Functions inherited from edm::one::EDFilter< EndRunProducer, BeginLuminosityBlockProducer, EndLuminosityBlockProducer, one::WatchRuns, one::WatchLuminosityBlocks, one::SharedResources >
	EDFilter ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDFilterBase
	EDFilterBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDFilterBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
unsigned int	counterRunInfoProducts_

Decayer *	decayer_

EDGetTokenT< LHEEventProduct >	eventProductToken_

HepMCFilterDriver *	filter_

Hadronizer	hadronizer_

unsigned int	nAttempts_

InputTag	runInfoProductTag_

EDGetTokenT< LHERunInfoProduct >	runInfoProductToken_

Additional Inherited Members
Static Public Member Functions inherited from edm::one::EDFilterBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

template<class HAD, class DEC>
class edm::HadronizerFilter< HAD, DEC >

Definition at line 55 of file HadronizerFilter.h.

Member Typedef Documentation

template<class HAD , class DEC >

typedef DEC edm::HadronizerFilter< HAD, DEC >::Decayer

Definition at line 64 of file HadronizerFilter.h.

template<class HAD , class DEC >

typedef HAD edm::HadronizerFilter< HAD, DEC >::Hadronizer

Definition at line 63 of file HadronizerFilter.h.

Constructor & Destructor Documentation

template<class HAD , class DEC >

edm::HadronizerFilter< HAD, DEC >::HadronizerFilter ( ParameterSet const & ps )

explicit

Definition at line 98 of file HadronizerFilter.h.

                                                                     :
     EDFilter(),
     hadronizer_(ps),
     decayer_(nullptr),
     filter_(nullptr),
     runInfoProductTag_(),
     runInfoProductToken_(),
     eventProductToken_(),
     counterRunInfoProducts_(0),
     nAttempts_(1)
   {
     callWhenNewProductsRegistered([this]( BranchDescription const& iBD) {
       //this is called each time a module registers that it will produce a LHERunInfoProduct
       if (iBD.unwrappedTypeID() == edm::TypeID(typeid(LHERunInfoProduct)) &&
           iBD.branchType() == InRun) {
         ++(this->counterRunInfoProducts_);
         this->eventProductToken_ = consumes<LHEEventProduct>(InputTag((iBD.moduleLabel()=="externalLHEProducer") ? "externalLHEProducer" : "source"));
         this->runInfoProductTag_ = InputTag(iBD.moduleLabel(), iBD.productInstanceName(), iBD.processName());
         this->runInfoProductToken_ = consumes<LHERunInfoProduct,InRun>(InputTag(iBD.moduleLabel(), iBD.productInstanceName(), iBD.processName()));
       }
     });
 
     // TODO:
     // Put the list of types produced by the filters here.
     // The current design calls for:
     //   * LHEGeneratorInfo
     //   * LHEEvent
     //   * HepMCProduct
     // But I can not find the LHEGeneratorInfo class; it might need to
     // be invented.
 
     std::vector<std::string> const& sharedResources = hadronizer_.sharedResources();
     for(auto const& resource : sharedResources) {
       usesResource(resource);
     }
 
     if ( ps.exists("ExternalDecays") )
     {
        //decayer_ = new gen::ExternalDecayDriver(ps.getParameter<ParameterSet>("ExternalDecays"));
        ParameterSet ps1 = ps.getParameter<ParameterSet>("ExternalDecays");
        decayer_ = new Decayer(ps1);
 
        std::vector<std::string> const& sharedResourcesDec = decayer_->sharedResources();
        for(auto const& resource : sharedResourcesDec) {
          usesResource(resource);
        }
     }
     
     if ( ps.exists("HepMCFilter") ) {
       ParameterSet psfilter = ps.getParameter<ParameterSet>("HepMCFilter");
       filter_ = new HepMCFilterDriver(psfilter);
     }
     
     //initialize setting for multiple hadronization attempts
     if (ps.exists("nAttempts")) {
       nAttempts_ = ps.getParameter<unsigned int>("nAttempts");
     }
     
     // This handles the case where there are no shared resources, because you
     // have to declare something when the SharedResources template parameter was used.
     if(sharedResources.empty() && (!decayer_ || decayer_->sharedResources().empty())) {
       usesResource(edm::uniqueSharedResourceName());
     }
 
     produces<edm::HepMCProduct>("unsmeared");
     produces<GenEventInfoProduct>();
     produces<GenLumiInfoHeader, edm::Transition::BeginLuminosityBlock>();
     produces<GenLumiInfoProduct, edm::Transition::EndLuminosityBlock>();
     produces<GenRunInfoProduct, edm::Transition::EndRun>();
     if(filter_)
       produces<GenFilterInfo, edm::Transition::EndLuminosityBlock>(); 
   }

template<class HAD , class DEC >

edm::HadronizerFilter< HAD, DEC >::~HadronizerFilter ( )

override

Definition at line 172 of file HadronizerFilter.h.

References edm::HadronizerFilter< HAD, DEC >::decayer_, and edm::HadronizerFilter< HAD, DEC >::filter_.

   {
     if (decayer_) delete decayer_;
     if (filter_) delete filter_;
   }

Member Function Documentation

template<class HAD , class DEC >

void edm::HadronizerFilter< HAD, DEC >::beginLuminosityBlock	(	LuminosityBlock const &	lumi,
		EventSetup const &	es
	)

override

Definition at line 350 of file HadronizerFilter.h.

351 {}

template<class HAD , class DEC >

void edm::HadronizerFilter< HAD, DEC >::beginLuminosityBlockProduce	(	LuminosityBlock &	lumi,
		EventSetup const &	es
	)

override

Definition at line 355 of file HadronizerFilter.h.

References edm::errors::Configuration, edm::HadronizerFilter< HAD, DEC >::decayer_, Exception, edm::HadronizerFilter< HAD, DEC >::filter_, genWeightsTable_cfi::genLumiInfoHeader, edm::HadronizerFilter< HAD, DEC >::hadronizer_, edm::LuminosityBlock::index(), lhef::LHERunInfo::initLumi(), eostools::move(), edm::LuminosityBlock::put(), and HepMCFilterDriver::resetStatistics().

   {
     lhef::LHERunInfo* lheRunInfo = hadronizer_.getLHERunInfo().get();
     lheRunInfo->initLumi();
 
     RandomEngineSentry<HAD> randomEngineSentry(&hadronizer_, lumi.index());
     RandomEngineSentry<DEC> randomEngineSentryDecay(decayer_, lumi.index());
     
     hadronizer_.randomizeIndex(lumi,randomEngineSentry.randomEngine());
     
     if ( !hadronizer_.readSettings(1) )
        throw edm::Exception(errors::Configuration) 
      << "Failed to read settings for the hadronizer "
      << hadronizer_.classname() << " \n";
 
     if ( decayer_ )
     {
        decayer_->init(es);
        if ( !hadronizer_.declareStableParticles( decayer_->operatesOnParticles() ) )
           throw edm::Exception(errors::Configuration)
             << "Failed to declare stable particles in hadronizer "
             << hadronizer_.classname()
         << " for internal parton generation\n";
        if ( !hadronizer_.declareSpecialSettings( decayer_->specialSettings() ) )
           throw edm::Exception(errors::Configuration)
             << "Failed to declare special settings in hadronizer "
             << hadronizer_.classname()
             << "\n";
     }
     
     if (filter_) {
       filter_->resetStatistics();
     }
 
     if (! hadronizer_.initializeForExternalPartons())
       throw edm::Exception(errors::Configuration) 
     << "Failed to initialize hadronizer "
     << hadronizer_.classname()
     << " for external parton generation\n";
         
     std::unique_ptr<GenLumiInfoHeader> genLumiInfoHeader(hadronizer_.getGenLumiInfoHeader());
     lumi.put(std::move(genLumiInfoHeader));
         
   }

template<class HAD , class DEC >

void edm::HadronizerFilter< HAD, DEC >::beginRun	(	Run const &	run,
		EventSetup const &	es
	)

override

Definition at line 291 of file HadronizerFilter.h.

References edm::HadronizerFilter< HAD, DEC >::counterRunInfoProducts_, edm::errors::EventCorruption, Exception, edm::Run::getByLabel(), edm::HadronizerFilter< HAD, DEC >::hadronizer_, lhef::LHERunInfo::initLumi(), and edm::HadronizerFilter< HAD, DEC >::runInfoProductTag_.

   {
         
     // this is run-specific
     
     // get LHE stuff and pass to hadronizer!
 
     if(counterRunInfoProducts_ > 1)
       throw edm::Exception(errors::EventCorruption)
         << "More than one LHERunInfoProduct present";
 
     if(counterRunInfoProducts_ == 0)
       throw edm::Exception(errors::EventCorruption)
         << "No LHERunInfoProduct present";
 
     edm::Handle<LHERunInfoProduct> lheRunInfoProduct;
     run.getByLabel(runInfoProductTag_, lheRunInfoProduct);
     //TODO: fix so that this actually works with getByToken commented below...
     //run.getByToken(runInfoProductToken_, lheRunInfoProduct);
     
     hadronizer_.setLHERunInfo( std::make_unique<lhef::LHERunInfo>(*lheRunInfoProduct) );
     lhef::LHERunInfo* lheRunInfo = hadronizer_.getLHERunInfo().get();
     lheRunInfo->initLumi();
 
   }

template<class HAD , class DEC >

void edm::HadronizerFilter< HAD, DEC >::endLuminosityBlock	(	LuminosityBlock const &	,
		EventSetup const &
	)

override

Definition at line 402 of file HadronizerFilter.h.

403 {}

template<class HAD , class DEC >

void edm::HadronizerFilter< HAD, DEC >::endLuminosityBlockProduce	(	LuminosityBlock &	lumi,
		EventSetup const &
	)

override

Definition at line 407 of file HadronizerFilter.h.

   {
     const lhef::LHERunInfo* lheRunInfo = hadronizer_.getLHERunInfo().get();
 
 
     std::vector<lhef::LHERunInfo::Process> LHELumiProcess = lheRunInfo->getLumiProcesses();
     std::vector<GenLumiInfoProduct::ProcessInfo> GenLumiProcess;
     for(unsigned int i=0; i < LHELumiProcess.size(); i++){
       lhef::LHERunInfo::Process thisProcess=LHELumiProcess[i];
 
       GenLumiInfoProduct::ProcessInfo temp;      
       temp.setProcess(thisProcess.process());
       temp.setLheXSec(thisProcess.getLHEXSec().value(),thisProcess.getLHEXSec().error());
       temp.setNPassPos(thisProcess.nPassPos());
       temp.setNPassNeg(thisProcess.nPassNeg());
       temp.setNTotalPos(thisProcess.nTotalPos());
       temp.setNTotalNeg(thisProcess.nTotalNeg());
       temp.setTried(thisProcess.tried().n(), thisProcess.tried().sum(), thisProcess.tried().sum2());
       temp.setSelected(thisProcess.selected().n(), thisProcess.selected().sum(), thisProcess.selected().sum2());
       temp.setKilled(thisProcess.killed().n(), thisProcess.killed().sum(), thisProcess.killed().sum2());
       temp.setAccepted(thisProcess.accepted().n(), thisProcess.accepted().sum(), thisProcess.accepted().sum2());
       temp.setAcceptedBr(thisProcess.acceptedBr().n(), thisProcess.acceptedBr().sum(), thisProcess.acceptedBr().sum2());
       GenLumiProcess.push_back(temp);
     }
     std::unique_ptr<GenLumiInfoProduct> genLumiInfo(new GenLumiInfoProduct());
     genLumiInfo->setHEPIDWTUP(lheRunInfo->getHEPRUP()->IDWTUP);
     genLumiInfo->setProcessInfo( GenLumiProcess );
 
     lumi.put(std::move(genLumiInfo));
 
 
     // produce GenFilterInfo if HepMCFilter is called
     if (filter_) {
 
       std::unique_ptr<GenFilterInfo> thisProduct(new GenFilterInfo(
                                  filter_->numEventsPassPos(),
                                  filter_->numEventsPassNeg(),
                                  filter_->numEventsTotalPos(),
                                  filter_->numEventsTotalNeg(),
                                  filter_->sumpass_w(),
                                  filter_->sumpass_w2(),
                                  filter_->sumtotal_w(),
                                  filter_->sumtotal_w2()
                                  ));
       lumi.put(std::move(thisProduct));
     }
       
 
   }

template<class HAD , class DEC >

void edm::HadronizerFilter< HAD, DEC >::endRun	(	Run const &	r,
		EventSetup const &
	)

override

Definition at line 319 of file HadronizerFilter.h.

319 {}

template<class HAD , class DEC >

void edm::HadronizerFilter< HAD, DEC >::endRunProduce	(	Run &	r,
		EventSetup const &
	)

override

Definition at line 323 of file HadronizerFilter.h.

References edm::HadronizerFilter< HAD, DEC >::decayer_, lhef::LHERunInfo::XSec::error(), edm::HadronizerFilter< HAD, DEC >::filter_, edm::HadronizerFilter< HAD, DEC >::hadronizer_, eostools::move(), edm::Run::put(), GenRunInfoProduct::setInternalXSec(), HepMCFilterDriver::statistics(), lhef::LHERunInfo::statistics(), lhef::LHERunInfo::XSec::value(), and lhef::LHERunInfo::xsec().

   {
     // Retrieve the LHE run info summary and transfer determined
     // cross-section into the generator run info
 
     const lhef::LHERunInfo* lheRunInfo = hadronizer_.getLHERunInfo().get();
     lhef::LHERunInfo::XSec xsec = lheRunInfo->xsec();
 
     GenRunInfoProduct& genRunInfo = hadronizer_.getGenRunInfo();
     genRunInfo.setInternalXSec( GenRunInfoProduct::XSec(xsec.value(), xsec.error()) );
 
     // If relevant, record the integrated luminosity for this run
     // here.  To do so, we would need a standard function to invoke on
     // the contained hadronizer that would report the integrated
     // luminosity.
 
     hadronizer_.statistics();
     if ( decayer_ ) decayer_->statistics();
     if ( filter_ ) filter_->statistics();
     lheRunInfo->statistics();
 
     std::unique_ptr<GenRunInfoProduct> griproduct( new GenRunInfoProduct(genRunInfo) );
     r.put(std::move(griproduct));
   }

template<class HAD , class DEC >

bool edm::HadronizerFilter< HAD, DEC >::filter	(	Event &	e,
		EventSetup const &	es
	)

overridevirtual

Implements edm::one::EDFilterBase.

Definition at line 180 of file HadronizerFilter.h.

References edm::HadronizerFilter< HAD, DEC >::decayer_, edm::EventID::event(), event(), edm::HadronizerFilter< HAD, DEC >::eventProductToken_, HepMCFilterDriver::filter(), edm::HadronizerFilter< HAD, DEC >::filter_, particlelevel_cff::genEventInfo, edm::Event::getByToken(), edm::HadronizerFilter< HAD, DEC >::hadronizer_, edm::EventBase::id(), eostools::move(), edm::HadronizerFilter< HAD, DEC >::nAttempts_, edm::Event::put(), edm::Event::streamID(), and protons_cff::t.

   {
     RandomEngineSentry<HAD> randomEngineSentry(&hadronizer_, ev.streamID());
     RandomEngineSentry<DEC> randomEngineSentryDecay(decayer_, ev.streamID());
 
     hadronizer_.setEDMEvent(ev);
 
     // get LHE stuff and pass to hadronizer!
     //
     edm::Handle<LHEEventProduct> product;
     ev.getByToken(eventProductToken_, product);
     
     std::unique_ptr<HepMC::GenEvent> finalEvent;
     std::unique_ptr<GenEventInfoProduct> finalGenEventInfo;
     
     //sum of weights for events passing hadronization
     double waccept = 0;
     //number of accepted events
     unsigned int naccept = 0;
     
     for (unsigned int itry = 0; itry<nAttempts_; ++itry) {
 
       hadronizer_.setLHEEvent(std::make_unique<lhef::LHEEvent>(hadronizer_.getLHERunInfo(), *product) );
       
       // hadronizer_.generatePartons();
       if ( !hadronizer_.hadronize() ) continue ;
 
       //  this is "fake" stuff
       // in principle, decays are done as part of full event generation,
       // except for particles that are marked as to be kept stable
       // but we currently keep in it the design, because we might want
       // to use such feature for other applications
       //
       if ( !hadronizer_.decay() ) continue;
       
       std::unique_ptr<HepMC::GenEvent> event (hadronizer_.getGenEvent());
       if( !event.get() ) continue; 
 
       // The external decay driver is being added to the system,
       // it should be called here
       //
       if ( decayer_ ) 
       {
         auto lheEvent = hadronizer_.getLHEEvent();
         auto t = decayer_->decay( event.get(),lheEvent.get() );
         if(t != event.get()) {
           event.reset(t);
         }
         hadronizer_.setLHEEvent(std::move(lheEvent));
       }
 
       if ( !event.get() ) continue;
 
       // check and perform if there're any unstable particles after 
       // running external decay packges
       //
       hadronizer_.resetEvent( std::move(event) );
       if ( !hadronizer_.residualDecay() ) continue;
 
       hadronizer_.finalizeEvent();
 
       event = hadronizer_.getGenEvent();
       if ( !event.get() ) continue;
       
       event->set_event_number( ev.id().event() );
       
       std::unique_ptr<GenEventInfoProduct> genEventInfo(hadronizer_.getGenEventInfo());
       if (!genEventInfo.get())
       { 
         // create GenEventInfoProduct from HepMC event in case hadronizer didn't provide one
         genEventInfo.reset(new GenEventInfoProduct(event.get()));
       }
       
       //if HepMCFilter was specified, test event
       if (filter_ && !filter_->filter(event.get(), genEventInfo->weight())) continue;      
       
       waccept += genEventInfo->weight();
       ++naccept;
       
       //keep the LAST accepted event (which is equivalent to choosing randomly from the accepted events)
       finalEvent = std::move(event);
       finalGenEventInfo = std::move(genEventInfo);
       
     }
     
     if (!naccept) return false;
     
 
     
     //adjust event weights if necessary (in case input event was attempted multiple times)
     if (nAttempts_>1) {
       double multihadweight = double(naccept)/double(nAttempts_);
       
       //adjust weight for GenEventInfoProduct
       finalGenEventInfo->weights()[0] *= multihadweight;
       
       //adjust weight for HepMC GenEvent (used e.g for RIVET)
       finalEvent->weights()[0] *= multihadweight;
     }
     
     ev.put(std::move(finalGenEventInfo));
 
     std::unique_ptr<HepMCProduct> bare_product(new HepMCProduct());
     bare_product->addHepMCData( finalEvent.release() );
     ev.put(std::move(bare_product), "unsmeared");
 
     return true;
   }