#include <HltComparator.h>

Inheritance diagram for HltComparator:

Public Member Functions
	HltComparator (const edm::ParameterSet &)

	~HltComparator ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDFilter ()

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 (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &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 Member Functions
virtual void	beginJob ()

virtual void	endJob ()

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

std::string	formatResult (const unsigned int)

void	initialise (const edm::TriggerResults &, const edm::TriggerResults &, edm::Event &e)

bool	verbose () const

Private Attributes
std::vector< TH1F * >	comparisonHists_

edm::EDGetTokenT < edm::TriggerResults >	hltOfflineResults_

edm::EDGetTokenT < edm::TriggerResults >	hltOnlineResults_

bool	init_

unsigned int	numTriggers_

std::vector< std::string >	offlineActualNames_

std::vector< std::string >	onlineActualNames_

std::vector< unsigned int >	onlineToOfflineBitMappings_

std::vector< std::string >	skipPathList_

std::map< unsigned int, std::map< std::string, unsigned int > >	triggerComparisonErrors_

std::vector< std::string >	usePathList_

bool	verbose_

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

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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::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 15 of file HltComparator.h.

Constructor & Destructor Documentation

HltComparator::HltComparator ( const edm::ParameterSet & iConfig )

explicit

Definition at line 32 of file HltComparator.cc.

                                                            :
   hltOnlineResults_(consumes<edm::TriggerResults>(iConfig.getParameter<edm::InputTag>("OnlineResults"))),
   hltOfflineResults_(consumes<edm::TriggerResults>(iConfig.getParameter<edm::InputTag>("OfflineResults"))),
   init_(false),
   verbose_(iConfig.getUntrackedParameter<bool>("verbose")),
   skipPathList_(iConfig.getUntrackedParameter<std::vector<std::string> >("skipPaths")),
   usePathList_(iConfig.getUntrackedParameter<std::vector<std::string> >("usePaths"))
 {
   //std::cout << " HERE I AM " << std::endl;
   produces<StringCollection >("failedTriggerDescription");
   //std::cout << " HERE I GO " << std::endl;
 }

HltComparator::~HltComparator ( )

Definition at line 46 of file HltComparator.cc.

47 {

48 }

Member Function Documentation

void HltComparator::beginJob ( void )

privatevirtual

Reimplemented from edm::EDFilter.

Definition at line 281 of file HltComparator.cc.

282 {

283 }

void HltComparator::endJob ( void )

privatevirtual

Reimplemented from edm::EDFilter.

Definition at line 287 of file HltComparator.cc.

References gather_cfg::cout, formatResult(), and triggerComparisonErrors_.

 {
 #ifdef NOTDEF
   std::cout << "HLT-Compare ---------- Trigger Comparison Summary ----------" << std::endl;
   std::cout << "HLT-Compare  The following events had trigger mismatches:" << std::endl;
   std::map<unsigned int, std::map<std::string, unsigned int> >::iterator it;
   for(it = triggerComparisonErrors_.begin(); it != triggerComparisonErrors_.end(); ++it) {
     std::cout << "HLT-Compare  Event: " << it->first << std::endl;
     std::map<std::string, unsigned int>::iterator jt;
     for(jt = it->second.begin(); jt != it->second.end(); ++jt) {
       std::cout << "HLT-Compare    Path: " << jt->first << " : " << formatResult(jt->second) << std::endl;
     }
   }
   std::cout << "HLT-Compare ------------ End Trigger Comparison ------------" << std::endl;
 #endif //NOTDEF
 }

bool HltComparator::filter	(	edm::Event &	event,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Implements edm::EDFilter.

Definition at line 157 of file HltComparator.cc.

References comparisonHists_, gather_cfg::cout, spr::find(), formatResult(), hltOfflineResults_, hltOnlineResults_, i, init_, initialise(), kOnErrorOffRun, kOnFailOffPass, kOnNotOffRun, kOnPassOffFail, kOnRunOffError, kOnRunOffNot, numTriggers_, onlineActualNames_, onlineToOfflineBitMappings_, mps_fire::result, skipPathList_, triggerComparisonErrors_, usePathList_, and verbose().

 {
   //std::cout << "top of the filter " << std::endl;
   // Get trigger results
   edm::Handle<edm::TriggerResults> onlineResults;
   edm::Handle<edm::TriggerResults> offlineResults;
   event.getByToken(hltOnlineResults_, onlineResults);
   event.getByToken(hltOfflineResults_, offlineResults);
 
   std::auto_ptr<StringCollection> resultDescription(new StringCollection);
   
   // Initialise comparator if required
   if (!init_) {
     initialise(*onlineResults, *offlineResults, event);
   }
   
   // Perform trigger checks
   bool hasDisagreement = false;
   for (unsigned int i = 0; i < numTriggers_; ++i) {
     unsigned int offlineTriggerBit = onlineToOfflineBitMappings_[i];
     
     bool onRun = onlineResults->wasrun(i);
     bool offRun = offlineResults->wasrun(offlineTriggerBit);
     bool onAccept = onlineResults->accept(i);
     bool offAccept = offlineResults->accept(offlineTriggerBit);
     bool onError = onlineResults->error(i);
     bool offError = offlineResults->error(offlineTriggerBit);
     
     int result = -1;
     if (onError || offError) {
       if (onError && offError) {
     result = 4;
       }
       else if (onError) {
     result = 6;
       }
       else {
     result = 5;
       }
     }
     else if ((!onRun) || (!offRun)) {
       if ((!onRun) && (!offRun)) {
     result = 9;
       }
       else if (!onRun) {
     result = 8;
       }
       else {
     result = 7;
       }
     }
     else {
       if (onAccept && offAccept) {
     result = 0;
       }
       else if ((!onAccept) && (!offAccept)) {
     result = 1;
       }
       else if (onAccept) {
     result = 2;
       }
       else {
     result = 3;
       }
     }
     
     // Fill the results histogram
     comparisonHists_[i]->Fill(result);
 
   // if the online-offline comparison results in a failure, we
   // want to send the result to a special stream. Hence we _pass_ the filter.
   // If it all worked as expected the filter fails and the event doesn't go
   // to the output stream.
     if ( (result == kOnPassOffFail) || ( result == kOnFailOffPass ) ||
      (result == kOnRunOffError) || ( result == kOnErrorOffRun ) ||
      (result == kOnRunOffNot)   || ( result == kOnNotOffRun ) ) {
       // is this one we should ignore? check the skip list
       if ( verbose() ) {
     std::cout << "Found disagreemenet " << result << ", name is " 
           << onlineActualNames_[i]
           << std::endl;
       }
       std::ostringstream desc;
       desc << onlineActualNames_[i] << ":" << formatResult(result);
       resultDescription->push_back(desc.str());
       if ( std::find(skipPathList_.begin(), skipPathList_.end(), 
              onlineActualNames_[i]) == skipPathList_.end() ) {
 
     if (usePathList_.size()!=0){
       //only use specified paths to debug
       if (std::find(usePathList_.begin(), usePathList_.end(),
             onlineActualNames_[i]) != usePathList_.end() )
         hasDisagreement = true;
     }
     else
       hasDisagreement = true;
       }
     }
       
     // Record the trigger error code
     // I think this should be result > 2? (pw)
     if (verbose() && (result > 1)) {
       std::cout << "HLT-Compare: Event " << event.id().event() 
         << " Path " << onlineActualNames_[i] << " " 
         << formatResult(result) << std::endl;
 #ifdef NOTDEF      
       triggerComparisonErrors_[event.id().event()][onlineActualNames_[i]] = result;
 #endif // NOTDEF
     }
   }
 
   //std::cout << " HERE I STAY " << std::endl;
   event.put(resultDescription,"failedTriggerDescription");
   //std::cout << " HERE I WENT " << std::endl;
 
   if ( hasDisagreement ) 
     return true;
   else
     return false;
 }

std::string HltComparator::formatResult ( const unsigned int i )

private

Definition at line 119 of file HltComparator.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by endJob(), and filter().

 {
   switch (i) {
   case 0:
     return std::string("OnPass_OffPass");
     break;
   case 1:
     return std::string("OnFail_OffFail");
     break;
   case 2:
     return std::string("OnPass_OffFail");
     break;
   case 3:
     return std::string("OnFail_OffPass");
     break;
   case 4:
     return std::string("OnError_OffError");
     break;
   case 5:
     return std::string("OnRun_OffError");
     break;
   case 6:
     return std::string("OnError_OffRun");
     break;
   case 7:
     return std::string("OnRun_OffNotRun");
     break;
   case 8:
     return std::string("OnNotRun_OffRun");
     break;
   case 9:
     return std::string("OnNotRun_OffNotRun");
     break;
   }
   return std::string("CODE NOT KNOWN");
 }

void HltComparator::initialise	(	const edm::TriggerResults &	onlineResults,
		const edm::TriggerResults &	offlineResults,
		edm::Event &	e
	)

private

Definition at line 52 of file HltComparator.cc.

References a, comparisonHists_, Exception, h, i, init_, TFileService::make(), numTriggers_, offlineActualNames_, onlineActualNames_, onlineToOfflineBitMappings_, edm::TriggerNames::triggerNames(), and edm::Event::triggerNames().

Referenced by filter().

 {
   init_ = true;
 
   // Get trigger names 
   const edm::TriggerNames & onlineTriggerNames = e.triggerNames(onlineResults);
   const edm::TriggerNames & offlineTriggerNames = e.triggerNames(offlineResults);
   onlineActualNames_ = onlineTriggerNames.triggerNames();
   offlineActualNames_ = offlineTriggerNames.triggerNames();
   numTriggers_ = onlineActualNames_.size();
   
   // do we need to throw? I guess the whole job is crap if this happens.
   // sort of assumes we're the only game in town.
   if (numTriggers_ != offlineActualNames_.size()) {
     throw cms::Exception("IncorrectTriggers") << "Online had "
                           << numTriggers_ << "triggers, "
                           << "Offline had " 
                           << offlineActualNames_.size()
                           << "triggers";
   }
 
   // Create bit mappings
   std::map<std::string, unsigned int >offlineNameBitMap;
   for (unsigned int i = 0; i < numTriggers_; ++i) {
     offlineNameBitMap[offlineActualNames_[i]] = i;
   }
   for (unsigned int i = 0; i < numTriggers_; ++i) {
     // Find offline position for fixed online bit
     std::map<std::string, unsigned int >::iterator it =
       offlineNameBitMap.find(onlineActualNames_[i]);
     if (it != offlineNameBitMap.end()) {
       onlineToOfflineBitMappings_.push_back(it->second);
     }
     else {
       throw cms:: Exception("IncorrectTriggers") << "Online trigger path " 
                          << onlineActualNames_[i] 
                          << " not found in Offline "
     "processing";
     }
   }
   
   // Create histograms
   edm::Service<TFileService> fs;
   for (std::vector<std::string>::iterator it = onlineActualNames_.begin();
        it != onlineActualNames_.end(); ++it) {
     // Bin descriptions: OnOfPass, OnOffFail, OnPassOffFail, OnFailOffPass, 
     // OnOffError, OnRunOffError, OnErrorOffRun, OnRunOffNot OnNotOffRun 
     // OnNotOffNot
     TH1F *h = fs->make<TH1F>(it->c_str(), it->c_str(), 10, 0, 10);
     TAxis *a = h->GetXaxis();
     a->SetBinLabel(1, "OnPass_OffPass");
     a->SetBinLabel(2, "OnFail_OffFail");
     a->SetBinLabel(3, "OnPass_OffFail");
     a->SetBinLabel(4, "OnFail_OffPass");
     a->SetBinLabel(5, "OnError_OffError");
     a->SetBinLabel(6, "OnRun_OffError");
     a->SetBinLabel(7, "OnError_OffRun");
     a->SetBinLabel(8, "OnRun_OffNotRun");
     a->SetBinLabel(9, "OnNotRun_OffRun");
     a->SetBinLabel(10, "OnNotRun_OffNotRun");
     comparisonHists_.push_back(h);
   }
 }

bool HltComparator::verbose ( ) const

inlineprivate

Definition at line 34 of file HltComparator.h.

References verbose_.

Referenced by filter().

34 { return verbose_; }

HltComparator::verbose_

bool verbose_

Definition: HltComparator.h:33

Member Data Documentation

std::vector<TH1F*> HltComparator::comparisonHists_

private

Definition at line 29 of file HltComparator.h.

Referenced by filter(), and initialise().

edm::EDGetTokenT<edm::TriggerResults> HltComparator::hltOfflineResults_

private

Definition at line 23 of file HltComparator.h.

Referenced by filter().

edm::EDGetTokenT<edm::TriggerResults> HltComparator::hltOnlineResults_

private

Definition at line 22 of file HltComparator.h.

Referenced by filter().

bool HltComparator::init_

private

Definition at line 32 of file HltComparator.h.

Referenced by filter(), and initialise().

unsigned int HltComparator::numTriggers_

private

Definition at line 39 of file HltComparator.h.

Referenced by filter(), and initialise().

std::vector<std::string> HltComparator::offlineActualNames_

private

Definition at line 26 of file HltComparator.h.

Referenced by initialise().

std::vector<std::string> HltComparator::onlineActualNames_

private

Definition at line 25 of file HltComparator.h.

Referenced by filter(), and initialise().

std::vector<unsigned int> HltComparator::onlineToOfflineBitMappings_

private

Definition at line 27 of file HltComparator.h.

Referenced by filter(), and initialise().

std::vector<std::string> HltComparator::skipPathList_

private

Definition at line 36 of file HltComparator.h.

Referenced by filter().

std::map<unsigned int, std::map<std::string, unsigned int> > HltComparator::triggerComparisonErrors_

private

Definition at line 30 of file HltComparator.h.

Referenced by endJob(), and filter().

std::vector<std::string> HltComparator::usePathList_

private

Definition at line 37 of file HltComparator.h.

Referenced by filter().

bool HltComparator::verbose_

private

Definition at line 33 of file HltComparator.h.

Referenced by verbose().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation