#include <MixingWorker.h>

Inheritance diagram for edm::MixingWorker< T >:

Public Member Functions
void	addPileups (const EventPrincipal &ep, ModuleCallingContext const *, unsigned int eventNr) override

void	addSignals (const edm::Event &e) override

bool	checkSignal (const edm::Event &e) override

virtual void	copyPCrossingFrame (const PCrossingFrame< T > *PCF)

void	createnewEDProduct () override

	MixingWorker ()

	MixingWorker (int minBunch, int maxBunch, int bunchSpace, std::string subdet, std::string label, std::string labelCF, int maxNbSources, InputTag &tag, InputTag &tagCF, bool makePCrossingFrame=false)

	MixingWorker (int minBunch, int maxBunch, int bunchSpace, std::string subdet, std::string label, std::string labelCF, int maxNbSources, InputTag &tag, InputTag &tagCF, std::vector< InputTag > const &tags)

void	put (edm::Event &e) override

void	reload (const edm::EventSetup &setup) override

void	setBcrOffset () override

void	setSourceOffset (const unsigned int s) override

void	setTof () override

	~MixingWorker () override

Public Member Functions inherited from edm::MixingWorkerBase
	MixingWorkerBase ()

virtual	~MixingWorkerBase ()

Private Attributes
std::vector< InputTag >	allTags_

int	bunchSpace_

std::unique_ptr< CrossingFrame< T > >	crFrame_

std::string const	label_

std::string const	labelCF_

bool const	makePCrossingFrame_

int	maxBunch_

unsigned int const	maxNbSources_

int	minBunch_

std::string const	subdet_

InputTag	tag_

InputTag	tagSignal_

Detailed Description

template<class T>
class edm::MixingWorker< T >

Definition at line 41 of file MixingWorker.h.

Constructor & Destructor Documentation

template<class T >

edm::MixingWorker< T >::MixingWorker ( )

inlineexplicit

standard constructor

Definition at line 46 of file MixingWorker.h.

                               :
         minBunch_(-5),
         maxBunch_(3),
         bunchSpace_(75),
         subdet_(std::string(" ")),
         label_(std::string(" ")),
         labelCF_(std::string(" ")),
         maxNbSources_(5),
         makePCrossingFrame_(false),
     tag_(),
     tagSignal_(),
         allTags_(),
         crFrame_(nullptr)
         {
     }

template<class T >

edm::MixingWorker< T >::MixingWorker	(	int	minBunch,
		int	maxBunch,
		int	bunchSpace,
		std::string	subdet,
		std::string	label,
		std::string	labelCF,
		int	maxNbSources,
		InputTag &	tag,
		InputTag &	tagCF,
		bool	makePCrossingFrame = `false`
	)

inline

Definition at line 63 of file MixingWorker.h.

                                                           :
     MixingWorkerBase(),
     minBunch_(minBunch),
     maxBunch_(maxBunch),
     bunchSpace_(bunchSpace),
     subdet_(subdet),
     label_(label),
     labelCF_(labelCF),
     maxNbSources_(maxNbSources),
     makePCrossingFrame_(makePCrossingFrame),
     tag_(tag),
     tagSignal_(tagCF),
         allTags_(),
         crFrame_(nullptr)
     {
     }

template<class T >

edm::MixingWorker< T >::MixingWorker	(	int	minBunch,
		int	maxBunch,
		int	bunchSpace,
		std::string	subdet,
		std::string	label,
		std::string	labelCF,
		int	maxNbSources,
		InputTag &	tag,
		InputTag &	tagCF,
		std::vector< InputTag > const &	tags
	)

inline

Definition at line 84 of file MixingWorker.h.

                                             : 
     MixingWorkerBase(),
     minBunch_(minBunch),
     maxBunch_(maxBunch),
     bunchSpace_(bunchSpace),
     subdet_(subdet),
     label_(label),
     labelCF_(labelCF),
     maxNbSources_(maxNbSources),
     makePCrossingFrame_(false),
     tag_(tag),
     tagSignal_(tagCF),
         allTags_(tags),
         crFrame_(nullptr)
     {
     }

template<class T >

edm::MixingWorker< T >::~MixingWorker ( )

inlineoverride

Default destructor

Definition at line 106 of file MixingWorker.h.

106 {;}

Member Function Documentation

template<typename T >

void MixingWorker::addPileups	(	const EventPrincipal &	ep,
		ModuleCallingContext const *	mcc,
		unsigned int	eventNr
	)

overridevirtual

Implements edm::MixingWorkerBase.

Definition at line 186 of file MixingWorker.h.

References edm::MixingWorker< T >::crFrame_, LogDebug, and edm::MixingWorker< T >::tag_.

Referenced by edm::MixingWorker< T >::addSignals().

                                                                                                                    {
     std::shared_ptr<Wrapper<std::vector<T> > const> shPtr = getProductByTag<std::vector<T> >(ep, tag_, mcc);
     if (shPtr) {
       LogDebug("MixingModule") << shPtr->product()->size() << "  pileup objects  added, eventNr " << eventNr;
       crFrame_->setPileupPtr(shPtr);
       crFrame_->addPileups(*shPtr->product());
     }
   }

template<class T >

void edm::MixingWorker< T >::addSignals ( const edm::Event & e )

inlineoverridevirtual

Implements edm::MixingWorkerBase.

Definition at line 139 of file MixingWorker.h.

References edm::MixingWorker< T >::addPileups(), edm::MixingWorker< T >::crFrame_, edm::Event::getByLabel(), edm::EventBase::id(), LogDebug, dataset::name, edm::Handle< T >::product(), and edm::MixingWorker< T >::tag_.

                                                  {
     edm::Handle<std::vector<T> > result_t;
     bool got = e.getByLabel(tag_,result_t);
     if (got) {
       LogDebug("MixingModule") <<" adding " << result_t.product()->size()<<" signal objects for "<<typeid(T).name()<<" with "<<tag_;
       crFrame_->addSignals(result_t.product(),e.id());
     } else {
           LogInfo("MixingModule") <<"!!!!!!! Did not get any signal data for "<<typeid(T).name()<<", with "<<tag_;
         }
       }

template<class T >

bool edm::MixingWorker< T >::checkSignal ( const edm::Event & e )

inlineoverridevirtual

Steps in BMixingModule::produce

Implements edm::MixingWorkerBase.

Definition at line 120 of file MixingWorker.h.

References edm::InputTag::encode(), edm::Event::getByLabel(), edm::InputTag::instance(), edm::InputTag::label(), dataset::name, lumiQTWidget::t, and edm::MixingWorker< T >::tag_.

                                                   {
           bool got;
       InputTag t;
       edm::Handle<std::vector<T> >  result_t;
       got = e.getByLabel(tag_,result_t);
       t = InputTag(tag_.label(),tag_.instance());
       
       if (got)
            LogInfo("MixingModule") <<" Will create a CrossingFrame for "<< typeid(T).name() 
                        << " with InputTag= "<< t.encode();
                        
       return got;
       }

template<class T >

void MixingWorker::copyPCrossingFrame ( const PCrossingFrame< T > * PCF )

virtual

Definition at line 203 of file MixingWorker.h.

References edm::MixingWorker< T >::crFrame_, PCrossingFrame< T >::getBunchRange(), PCrossingFrame< T >::getBunchSpace(), PCrossingFrame< T >::getIdFirstPileup(), PCrossingFrame< T >::getMaxNbSources(), PCrossingFrame< T >::getPileupFileNr(), PCrossingFrame< T >::getPileupOffsetsBcr(), PCrossingFrame< T >::getPileupOffsetsSource(), PCrossingFrame< T >::getPileups(), and PCrossingFrame< T >::getSubDet().

Referenced by edm::MixingWorker< T >::put().

     { 
       crFrame_->setBunchRange(PCF->getBunchRange()); 
       crFrame_->setBunchSpace(PCF->getBunchSpace());
       crFrame_->setMaxNbSources(PCF->getMaxNbSources());
       crFrame_->setSubDet(PCF->getSubDet());
       crFrame_->setPileupOffsetsBcr(PCF->getPileupOffsetsBcr());
       crFrame_->setPileupOffsetsSource(PCF->getPileupOffsetsSource());
       crFrame_->setPileups(PCF->getPileups());
       
       // For playback option
       crFrame_->setPileupFileNr(PCF->getPileupFileNr());
       crFrame_->setIdFirstPileup(PCF->getIdFirstPileup());
     }

template<class T >

void edm::MixingWorker< T >::createnewEDProduct ( )

inlineoverridevirtual

Implements edm::MixingWorkerBase.

Definition at line 135 of file MixingWorker.h.

References edm::MixingWorker< T >::bunchSpace_, edm::MixingWorker< T >::crFrame_, edm::MixingWorker< T >::maxBunch_, edm::MixingWorker< T >::maxNbSources_, edm::MixingWorker< T >::minBunch_, and edm::MixingWorker< T >::subdet_.

                                         {        
         crFrame_ = std::make_unique<CrossingFrame<T> >(minBunch_,maxBunch_,bunchSpace_,subdet_,maxNbSources_);
       }

template<class T >

void edm::MixingWorker< T >::put ( edm::Event & e )

inlineoverridevirtual

Implements edm::MixingWorkerBase.

Definition at line 157 of file MixingWorker.h.

References edm::MixingWorker< T >::copyPCrossingFrame(), edm::MixingWorker< T >::crFrame_, edm::MixingWorker< T >::label_, LogDebug, edm::MixingWorker< T >::makePCrossingFrame_, eostools::move(), dataset::name, and edm::Event::put().

                                      {  
         if(makePCrossingFrame_) {
           e.put(std::make_unique<PCrossingFrame<T> >(*crFrame_), label_);
         }
     e.put(std::move(crFrame_),label_);
     LogDebug("MixingModule") <<" CF was put for type "<<typeid(T).name()<<" with "<<label_;
       }

template<class T >

void edm::MixingWorker< T >::reload ( const edm::EventSetup & setup )

inlineoverridevirtual

Reimplemented from edm::MixingWorkerBase.

Definition at line 110 of file MixingWorker.h.

References MixingModuleConfig::bunchSpace(), edm::MixingWorker< T >::bunchSpace_, looper::config, edm::EventSetup::get(), MixingModuleConfig::maxBunch(), edm::MixingWorker< T >::maxBunch_, MixingModuleConfig::minBunch(), and edm::MixingWorker< T >::minBunch_.

                                                        {
     //get the required parameters from DB.
     // watch the label/tag
     edm::ESHandle<MixingModuleConfig> config;
     setup.get<MixingRcd>().get(config);
     minBunch_=config->minBunch();
     maxBunch_=config->maxBunch();
     bunchSpace_=config->bunchSpace();
       }