Inheritance diagram for RecoTauDifferenceAnalyzer:

Public Member Functions
virtual void	endJob () override

virtual bool	filter (edm::Event &evt, const edm::EventSetup &es) override

	RecoTauDifferenceAnalyzer (const edm::ParameterSet &pset)

virtual	~RecoTauDifferenceAnalyzer ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDFilter ()

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
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
size_t	allPassed1_

size_t	allPassed2_

size_t	differences_

edm::InputTag	disc1_

edm::InputTag	disc2_

size_t	eventsExamined_

bool	filter_

double	maxDeltaR_

size_t	passed1_

size_t	passed2_

edm::InputTag	src1_

edm::InputTag	src2_

size_t	tausExamined_

Additional Inherited Members
Public Types inherited from edm::EDFilter
typedef EDFilter	ModuleType

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

Static Public Member Functions inherited from edm::EDFilter
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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 10 of file RecoTauDifferenceAnalyzer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 32 of file RecoTauDifferenceAnalyzer.cc.

References allPassed1_, allPassed2_, differences_, disc1_, disc2_, eventsExamined_, edm::ParameterSet::exists(), filter_, edm::ParameterSet::getParameter(), passed1_, passed2_, src1_, src2_, and tausExamined_.

                                  {
   src1_ = pset.getParameter<edm::InputTag>("src1");
   src2_ = pset.getParameter<edm::InputTag>("src2");
   disc1_ = pset.getParameter<edm::InputTag>("disc1");
   disc2_ = pset.getParameter<edm::InputTag>("disc2");
   eventsExamined_ = 0;
   tausExamined_ = 0;
   differences_ = 0;
   passed1_ = 0;
   passed2_ = 0;
   allPassed2_ = 0;
   allPassed1_ = 0;
   filter_ = pset.exists("filter") ? pset.getParameter<bool>("filter") : false;
 }

virtual RecoTauDifferenceAnalyzer::~RecoTauDifferenceAnalyzer ( )

inlinevirtual

Definition at line 13 of file RecoTauDifferenceAnalyzer.cc.

13 {}

Member Function Documentation

void RecoTauDifferenceAnalyzer::endJob ( void )

overridevirtual

Reimplemented from edm::EDFilter.

Definition at line 120 of file RecoTauDifferenceAnalyzer.cc.

References allPassed1_, allPassed2_, gather_cfg::cout, differences_, disc1_, disc2_, eventsExamined_, passed1_, passed2_, src1_, src2_, and tausExamined_.

                                        {
   std::cout <<  " RECO TAU DIFFERENCE SUMMARY: " << std::endl;
   std::cout <<  " Examined " << tausExamined_ << " taus in "
     << eventsExamined_ << " events." << std::endl;
   std::cout << " There were " << differences_ << " differences." << std::endl;
   std::cout << src1_ << "," << disc1_ << " had "
     << allPassed1_ << " total passes and "
     << passed1_ << " exclusive passes." << std::endl;
   std::cout << src2_ << "," << disc2_ << " had "
     << allPassed2_ << " total passes and "
     << passed2_ << " exclusive passes." << std::endl;
 }

bool RecoTauDifferenceAnalyzer::filter	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

overridevirtual

Implements edm::EDFilter.

Definition at line 58 of file RecoTauDifferenceAnalyzer.cc.

References allPassed1_, allPassed2_, deltar::bestMatch(), gather_cfg::cout, deltaR(), differences_, disc1_, disc2_, eventsExamined_, filter_, edm::Event::getByLabel(), edm::Ref< C, T, F >::isNull(), passed1_, passed2_, src1_, src2_, and tausExamined_.

                                             {
   eventsExamined_++;
   // Get taus
   edm::Handle<reco::PFTauCollection> taus1;
   evt.getByLabel(src1_, taus1);
   edm::Handle<reco::PFTauCollection> taus2;
   evt.getByLabel(src2_, taus2);
 
   // Get discriminators
   edm::Handle<reco::PFTauDiscriminator> disc1;
   evt.getByLabel(disc1_, disc1);
   edm::Handle<reco::PFTauDiscriminator> disc2;
   evt.getByLabel(disc2_, disc2);
 
   bool differenceFound = false;
   // Loop over first collection
   for (size_t iTau1 = 0; iTau1 < taus1->size(); ++iTau1) {
     tausExamined_++;
     reco::PFTauRef tau1(taus1, iTau1);
     // Find the best match in the other collection
     reco::PFTauRef bestMatch;
     double bestDeltaR = -1;
     for (size_t iTau2 = 0; iTau2 < taus2->size(); ++iTau2) {
       reco::PFTauRef tau2(taus2, iTau2);
       reco::PFJetRef jet1 = getJetRef(*tau1);
       reco::PFJetRef jet2 = getJetRef(*tau2);
       double deltaRVal = deltaR(jet2->p4(), jet1->p4());
       if (bestMatch.isNull() || deltaRVal < bestDeltaR) {
         bestMatch = tau2;
         bestDeltaR = deltaRVal;
       }
     }
     // See what's up with the discriminators
     bool result1 = ((*disc1)[tau1] > 0.5);
     bool result2 = ((*disc2)[bestMatch] > 0.5);
     allPassed1_ += result1;
     allPassed2_ += result2;
     if (result1 ^ result2) {
       differenceFound = true;
       passed1_ += result1;
       passed2_ += result2;
       differences_++;
       std::cout << "********* RecoTau difference detected! *************"
           << std::endl;
       std::cout << " Tau1 InputTag: " << src1_ << " result: " << result1
           << std::endl;
       std::cout << " Tau2 InputTag: " << src2_ << " result: " << result2
           << std::endl;
       std::cout << "---------       Tau 1                  -------------"
           << std::endl;
       std::cout << *tau1 << std::endl;
       tau1->dump(std::cout);
       std::cout << "---------       Tau 2                  -------------"
           << std::endl;
       std::cout << *bestMatch << std::endl;
       bestMatch->dump(std::cout);
     }
   }
   return (filter_ ? differenceFound : true);
 }