Inheritance diagram for RecoTauPiZeroProducer:

Public Types
typedef reco::tau::RecoTauPiZeroBuilderPlugin	Builder

typedef reco::tau::RecoTauPiZeroQualityPlugin	Ranker

Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Member Functions
void	print (const std::vector< reco::RecoTauPiZero > &piZeros, std::ostream &out)

void	produce (edm::Event &evt, const edm::EventSetup &es) override

	RecoTauPiZeroProducer (const edm::ParameterSet &pset)

	~RecoTauPiZeroProducer ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	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
	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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Types
typedef boost::ptr_vector < Builder >	builderList

typedef boost::ptr_list < reco::RecoTauPiZero >	PiZeroList

typedef reco::tau::RecoTauLexicographicalRanking < rankerList, reco::RecoTauPiZero >	PiZeroPredicate

typedef boost::ptr_vector < reco::RecoTauPiZero >	PiZeroVector

typedef boost::ptr_vector< Ranker >	rankerList

Private Attributes
builderList	builders_

edm::EDGetTokenT < reco::CandidateView >	cand_token

std::auto_ptr < StringCutObjectSelector < reco::RecoTauPiZero > >	outputSelector_

double	piZeroMass_

std::auto_ptr< PiZeroPredicate >	predicate_

rankerList	rankers_

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

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

Definition at line 40 of file RecoTauPiZeroProducer.cc.

Member Typedef Documentation

typedef reco::tau::RecoTauPiZeroBuilderPlugin RecoTauPiZeroProducer::Builder

Definition at line 42 of file RecoTauPiZeroProducer.cc.

typedef boost::ptr_vector<Builder> RecoTauPiZeroProducer::builderList

private

Definition at line 52 of file RecoTauPiZeroProducer.cc.

typedef boost::ptr_list<reco::RecoTauPiZero> RecoTauPiZeroProducer::PiZeroList

private

Definition at line 55 of file RecoTauPiZeroProducer.cc.

typedef reco::tau::RecoTauLexicographicalRanking<rankerList, reco::RecoTauPiZero> RecoTauPiZeroProducer::PiZeroPredicate

private

Definition at line 58 of file RecoTauPiZeroProducer.cc.

typedef boost::ptr_vector<reco::RecoTauPiZero> RecoTauPiZeroProducer::PiZeroVector

private

Definition at line 54 of file RecoTauPiZeroProducer.cc.

typedef reco::tau::RecoTauPiZeroQualityPlugin RecoTauPiZeroProducer::Ranker

Definition at line 43 of file RecoTauPiZeroProducer.cc.

typedef boost::ptr_vector<Ranker> RecoTauPiZeroProducer::rankerList

private

Definition at line 53 of file RecoTauPiZeroProducer.cc.

Constructor & Destructor Documentation

RecoTauPiZeroProducer::RecoTauPiZeroProducer ( const edm::ParameterSet & pset )

explicit

Definition at line 73 of file RecoTauPiZeroProducer.cc.

References builders_, cand_token, edm::EDConsumerBase::consumesCollector(), SurfaceDeformationFactory::create(), edm::ParameterSet::exists(), reco::get(), edm::ParameterSet::getParameter(), outputSelector_, piZeroMass_, predicate_, rankers_, corrVsCorr::selection, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                         {
   cand_token = consumes<reco::CandidateView>( pset.getParameter<edm::InputTag>("jetSrc"));
 
   typedef std::vector<edm::ParameterSet> VPSet;
   // Get the mass hypothesis for the pizeros
   piZeroMass_ = pset.getParameter<double>("massHypothesis");
 
   // Get each of our PiZero builders
   const VPSet& builders = pset.getParameter<VPSet>("builders");
   for (VPSet::const_iterator builderPSet = builders.begin();
       builderPSet != builders.end(); ++builderPSet) {
     // Get plugin name
     const std::string& pluginType =
       builderPSet->getParameter<std::string>("plugin");
     // Build the plugin
     builders_.push_back(RecoTauPiZeroBuilderPluginFactory::get()->create(
                                      pluginType, *builderPSet, consumesCollector()));
   }
 
   // Get each of our quality rankers
   const VPSet& rankers = pset.getParameter<VPSet>("ranking");
   for (VPSet::const_iterator rankerPSet = rankers.begin();
       rankerPSet != rankers.end(); ++rankerPSet) {
     const std::string& pluginType =
       rankerPSet->getParameter<std::string>("plugin");
     rankers_.push_back(RecoTauPiZeroQualityPluginFactory::get()->create(
           pluginType, *rankerPSet));
   }
 
   // Build the sorting predicate
   predicate_ = std::auto_ptr<PiZeroPredicate>(new PiZeroPredicate(rankers_));
 
   // Check if we want to apply a final output selection
   if (pset.exists("outputSelection")) {
     std::string selection = pset.getParameter<std::string>("outputSelection");
     if (selection != "") {
       outputSelector_.reset(
           new StringCutObjectSelector<reco::RecoTauPiZero>(selection));
     }
   }
 
   produces<reco::JetPiZeroAssociation>();
 }

RecoTauPiZeroProducer::~RecoTauPiZeroProducer ( )

inline

Definition at line 46 of file RecoTauPiZeroProducer.cc.

46 {}

Member Function Documentation

void RecoTauPiZeroProducer::print	(	const std::vector< reco::RecoTauPiZero > &	piZeros,
		std::ostream &	out
	)

Definition at line 221 of file RecoTauPiZeroProducer.cc.

References rankers_, and create_public_lumi_plots::width.

                                                                   {
   const unsigned int width = 25;
   BOOST_FOREACH(const reco::RecoTauPiZero& piZero, piZeros) {
     out << piZero;
     out << "* Rankers:" << std::endl;
     for (rankerList::const_iterator ranker = rankers_.begin();
         ranker != rankers_.end(); ++ranker) {
       out << "* " << std::setiosflags(std::ios::left)
         << std::setw(width) << ranker->name()
         << " " << std::resetiosflags(std::ios::left)
         << std::setprecision(3) << (*ranker)(piZero);
       out << std::endl;
     }
   }
 }

void RecoTauPiZeroProducer::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

overridevirtual

Implements edm::EDProducer.

Definition at line 117 of file RecoTauPiZeroProducer.cc.

References builders_, cand_token, cppFunctionSkipper::exception, edm::Event::getByToken(), metsig::jet, edm::Ref< C, T, F >::key(), reco::tau::RecoTauNamedPlugin::name(), outputSelector_, piZeroMass_, predicate_, edm::Event::put(), query::result, AddFourMomenta::set(), reco::LeafCandidate::setMass(), reco::tau::RecoTauEventHolderPlugin::setup(), edm::RefVector< C, T, F >::size(), and makeLayoutFileForGui::toAdd.

                                                              {
   // Get a view of our jets via the base candidates
   edm::Handle<reco::CandidateView> jetView;
   evt.getByToken(cand_token, jetView);
 
   // Give each of our plugins a chance at doing something with the edm::Event
   BOOST_FOREACH(Builder& builder, builders_) {
     builder.setup(evt, es);
   }
 
   // Convert the view to a RefVector of actual PFJets
   reco::PFJetRefVector jetRefs =
       reco::tau::castView<reco::PFJetRefVector>(jetView);
   // Make our association
   std::auto_ptr<reco::JetPiZeroAssociation> association;
 
   if (jetRefs.size()) {
     association.reset(
         new reco::JetPiZeroAssociation(reco::PFJetRefProd(jetRefs)));
   } else {
     association.reset(new reco::JetPiZeroAssociation);
   }
 
   // Loop over our jets
   BOOST_FOREACH(const reco::PFJetRef& jet, jetRefs) {
     // Build our global list of RecoTauPiZero
     PiZeroList dirtyPiZeros;
 
     // Compute the pi zeros from this jet for all the desired algorithms
     BOOST_FOREACH(const Builder& builder, builders_) {
       try {
         PiZeroVector result(builder(*jet));
         dirtyPiZeros.transfer(dirtyPiZeros.end(), result);
       } catch ( cms::Exception &exception) {
         edm::LogError("BuilderPluginException")
             << "Exception caught in builder plugin " << builder.name()
             << ", rethrowing" << std::endl;
         throw exception;
       }
     }
     // Rank the candidates according to our quality plugins
     dirtyPiZeros.sort(*predicate_);
 
     // Keep track of the photons in the clean collection
     std::vector<reco::RecoTauPiZero> cleanPiZeros;
     std::set<reco::CandidatePtr> photonsInCleanCollection;
     while (dirtyPiZeros.size()) {
       // Pull our candidate pi zero from the front of the list
       std::auto_ptr<reco::RecoTauPiZero> toAdd(
           dirtyPiZeros.pop_front().release());
       // If this doesn't pass our basic selection, discard it.
       if (!(*outputSelector_)(*toAdd)) {
         continue;
       }
       // Find the sub-gammas that are not already in the cleaned collection
       std::vector<reco::CandidatePtr> uniqueGammas;
       std::set_difference(toAdd->daughterPtrVector().begin(),
                           toAdd->daughterPtrVector().end(),
                           photonsInCleanCollection.begin(),
                           photonsInCleanCollection.end(),
                           std::back_inserter(uniqueGammas));
       // If the pi zero has no unique gammas, discard it.  Note toAdd is deleted
       // when it goes out of scope.
       if (!uniqueGammas.size()) {
         continue;
       } else if (uniqueGammas.size() == toAdd->daughterPtrVector().size()) {
         // Check if it is composed entirely of unique gammas.  In this case
         // immediately add it to the clean collection.
         photonsInCleanCollection.insert(toAdd->daughterPtrVector().begin(),
                                         toAdd->daughterPtrVector().end());
         cleanPiZeros.push_back(*toAdd);
       } else {
         // Otherwise update the pizero that contains only the unique gammas and
         // add it back into the sorted list of dirty PiZeros
         toAdd->clearDaughters();
         // Add each of the unique daughters back to the pizero
         BOOST_FOREACH(const reco::CandidatePtr& gamma, uniqueGammas) {
           toAdd->addDaughter(gamma);
         }
         // Update the four vector
         AddFourMomenta p4Builder_;
         p4Builder_.set(*toAdd);
         // Put this pi zero back into the collection of sorted dirty pizeros
         PiZeroList::iterator insertionPoint = std::lower_bound(
             dirtyPiZeros.begin(), dirtyPiZeros.end(), *toAdd, *predicate_);
         dirtyPiZeros.insert(insertionPoint, toAdd);
       }
     }
     // Apply the mass hypothesis if desired
     if (piZeroMass_ >= 0) {
       std::for_each(
           cleanPiZeros.begin(), cleanPiZeros.end(),
           std::bind2nd(
               std::mem_fun_ref(&reco::RecoTauPiZero::setMass), piZeroMass_));
     }
     // Add to association
     //print(cleanPiZeros, std::cout);
     association->setValue(jet.key(), cleanPiZeros);
   }
   evt.put(association);
 }