#include <GeneratorFilter.h>

Inheritance diagram for edm::GeneratorFilter< 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
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

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

virtual void	endLuminosityBlockProduce (LuminosityBlock &, EventSetup const &) override

virtual void	endRunProduce (Run &, EventSetup const &) override

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

	GeneratorFilter (ParameterSet const &ps)

virtual	~GeneratorFilter ()

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

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

ModuleDescription const &	moduleDescription () const

virtual	~EDFilterBase ()

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

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Attributes
Decayer *	decayer_

Hadronizer	hadronizer_

unsigned int	nEventsInLumiBlock_

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 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::GeneratorFilter< HAD, DEC >

Definition at line 38 of file GeneratorFilter.h.

Member Typedef Documentation

template<class HAD , class DEC >

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

Definition at line 45 of file GeneratorFilter.h.

template<class HAD , class DEC >

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

Definition at line 44 of file GeneratorFilter.h.

Constructor & Destructor Documentation

template<class HAD , class DEC >

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

explicit

Definition at line 71 of file GeneratorFilter.h.

References edm::GeneratorFilter< HAD, DEC >::decayer_, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::GeneratorFilter< HAD, DEC >::hadronizer_, and edm::uniqueSharedResourceName().

                                                                   :
     EDFilter(),
     hadronizer_(ps),
     decayer_(0),
     nEventsInLumiBlock_(0)
   {
     // TODO:
     // Put the list of types produced by the filters here.
     // The current design calls for:
     //   * GenRunInfoProduct
     //   * HepMCProduct
     //
     // other maybe added as needs be
     //
 
     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);
        }
     }
     // 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<GenLumiInfoProduct, edm::InLumi>();
     produces<GenRunInfoProduct, edm::InRun>();
  
   }

template<class HAD , class DEC >

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

virtual

Definition at line 116 of file GeneratorFilter.h.

117 { if ( decayer_ ) delete decayer_;}

edm::GeneratorFilter::decayer_

Decayer * decayer_

Definition: GeneratorFilter.h:62

Member Function Documentation

template<class HAD , class DEC >

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

overridevirtual

Definition at line 217 of file GeneratorFilter.h.

References edm::errors::Configuration, Exception, and edm::LuminosityBlock::index().

   {
     nEventsInLumiBlock_ = 0;
     RandomEngineSentry<HAD> randomEngineSentry(&hadronizer_, lumi.index());
     RandomEngineSentry<DEC> randomEngineSentryDecay(decayer_, lumi.index());
 
     if ( !hadronizer_.readSettings(0) )
        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()
             << "\n";
        if ( !hadronizer_.declareSpecialSettings( decayer_->specialSettings() ) )
           throw edm::Exception(errors::Configuration)
             << "Failed to declare special settings in hadronizer "
             << hadronizer_.classname()
             << "\n";
     }
 
     if ( !hadronizer_.initializeForInternalPartons() )
        throw edm::Exception(errors::Configuration) 
      << "Failed to initialize hadronizer "
      << hadronizer_.classname()
      << " for internal parton generation\n";
   }

template<class HAD , class DEC >

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

overridevirtual

Definition at line 252 of file GeneratorFilter.h.

253 {}

template<class HAD , class DEC >

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

overridevirtual

Definition at line 257 of file GeneratorFilter.h.

   {
     hadronizer_.statistics();    
     if ( decayer_ ) decayer_->statistics();
 
     GenRunInfoProduct genRunInfo = GenRunInfoProduct(hadronizer_.getGenRunInfo());
     std::vector<GenLumiInfoProduct::ProcessInfo> GenLumiProcess;
     GenRunInfoProduct::XSec xsec = genRunInfo.internalXSec();
     GenLumiInfoProduct::ProcessInfo temp;      
     temp.setProcess(0);
     temp.setLheXSec(xsec.value(), xsec.error()); // Pythia gives error of -1
     temp.setNPassPos(nEventsInLumiBlock_);
     temp.setNPassNeg(0);
     temp.setNTotalPos(nEventsInLumiBlock_);
     temp.setNTotalNeg(0);
     temp.setTried(nEventsInLumiBlock_, nEventsInLumiBlock_, nEventsInLumiBlock_);
     temp.setSelected(nEventsInLumiBlock_, nEventsInLumiBlock_, nEventsInLumiBlock_);
     temp.setKilled(nEventsInLumiBlock_, nEventsInLumiBlock_, nEventsInLumiBlock_);
     temp.setAccepted(0,-1,-1);
     temp.setAcceptedBr(0,-1,-1);
     GenLumiProcess.push_back(temp);
 
     std::auto_ptr<GenLumiInfoProduct> genLumiInfo(new GenLumiInfoProduct());
     genLumiInfo->setHEPIDWTUP(-1);
     genLumiInfo->setProcessInfo( GenLumiProcess );
     lumi.put(genLumiInfo);
 
     nEventsInLumiBlock_ = 0;
 
   }

template<class HAD , class DEC >

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

overridevirtual

Definition at line 200 of file GeneratorFilter.h.

References edm::Run::put().

   {
     // 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();
     
     std::auto_ptr<GenRunInfoProduct> griproduct(new GenRunInfoProduct(hadronizer_.getGenRunInfo()));
     r.put(griproduct);
   }

template<class HAD , class DEC >

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

overridevirtual

Implements edm::one::EDFilterBase.

Definition at line 121 of file GeneratorFilter.h.

References edm::EventID::event(), event(), edm::EventBase::id(), edm::Event::put(), and edm::Event::streamID().

   {
     RandomEngineSentry<HAD> randomEngineSentry(&hadronizer_, ev.streamID());
     RandomEngineSentry<DEC> randomEngineSentryDecay(decayer_, ev.streamID());
 
     //added for selecting/filtering gen events, in the case of hadronizer+externalDecayer
       
     bool passEvtGenSelector = false;
     std::auto_ptr<HepMC::GenEvent> event(0);
    
     while(!passEvtGenSelector)
       {
     event.reset();
     hadronizer_.setEDMEvent(ev);
     
     if ( !hadronizer_.generatePartonsAndHadronize() ) return false;
     
     //  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() ) return false;
     
     event = std::auto_ptr<HepMC::GenEvent>(hadronizer_.getGenEvent());
     if ( !event.get() ) return false; 
     
     // The external decay driver is being added to the system,
     // it should be called here
     //
     if ( decayer_ ) 
       {
         event.reset( decayer_->decay( event.get() ) );
       }
     if ( !event.get() ) return false;
     
     passEvtGenSelector = hadronizer_.select( event.get() );
     
       }
     // check and perform if there're any unstable particles after 
     // running external decay packages
     //
     // fisrt of all, put back modified event tree (after external decay)
     //
     hadronizer_.resetEvent( event.release() );
     
     //
     // now run residual decays
     //
     if ( !hadronizer_.residualDecay() ) return false;
         
     hadronizer_.finalizeEvent();
     
     event.reset( hadronizer_.getGenEvent() );
     if ( !event.get() ) return false;
     
     event->set_event_number( ev.id().event() );
     
     //
     // tutto bene - finally, form up EDM products !
     //
     std::auto_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()));
       }
     ev.put(genEventInfo);
    
     std::auto_ptr<HepMCProduct> bare_product(new HepMCProduct());
     bare_product->addHepMCData( event.release() );
     ev.put(bare_product, "unsmeared");
     nEventsInLumiBlock_ ++;
     return true;
   }