cut-flow versioning info in the event provenance More...

#include "PhysicsTools/SelectorUtils/interface/VersionedSelector.h"

Inheritance diagram for VersionedSelector< T >:

Public Member Functions
const size_t	cutFlowSize () const

const unsigned	howFarInCutFlow () const

void	initialize (const edm::ParameterSet &)

const unsigned char *	md55Raw () const

const std::string &	md5String () const

const std::string &	name () const

bool	operator() (const T &ref, pat::strbitset &ret) overridefinal
	This provides the interface for base classes to select objects. More...

bool	operator() (const T &ref, edm::EventBase const &e, pat::strbitset &ret) overridefinal
	This provides an alternative signature that includes extra information. More...

bool	operator== (const VersionedSelector &other) const

void	setConsumes (edm::ConsumesCollector)

	VersionedSelector ()

	VersionedSelector (const edm::ParameterSet &conf)

Public Member Functions inherited from Selector< T >
void	clear (std::string const &s)
	Turn off a given selection cut. More...

void	clear (index_type const &i)

bool	considerCut (std::string const &s) const
	consider the cut at index "s" More...

bool	considerCut (index_type const &i) const

int	cut (index_type const &i, int val) const
	Access the int cut values at index "s". More...

double	cut (index_type const &i, double val) const
	Access the double cut values at index "s". More...

int	cut (std::string s, int val) const
	Access the int cut values at index "s". More...

double	cut (std::string s, double val) const
	Access the double cut values at index "s". More...

pat::strbitset	getBitTemplate () const
	Get an empty bitset with the proper names. More...

double	getPasses (std::string const &s) const
	Return the number of passing cases. More...

double	getPasses (index_type const &i) const

bool	ignoreCut (std::string const &s) const
	ignore the cut at index "s" More...

bool	ignoreCut (index_type const &i) const

virtual bool	operator() (T const &t)
	This provides an alternative signature without the second ret. More...

virtual bool	operator() (T const &t, edm::EventBase const &e)
	This provides an alternative signature that includes extra information. More...

bool	operator[] (std::string const &s) const

bool	operator[] (index_type const &i) const

void	passCut (pat::strbitset &ret, std::string const &s)
	Passing cuts. More...

void	passCut (pat::strbitset &ret, index_type const &i)

void	print (std::ostream &out) const
	Print the cut flow. More...

void	printActiveCuts (std::ostream &out) const
	Print the cuts being considered. More...

virtual void	push_back (std::string const &s)
	This is the registration of an individual cut string. More...

virtual void	push_back (std::string const &s, int cut)
	This is the registration of an individual cut string, with an int cut value. More...

virtual void	push_back (std::string const &s, double cut)
	This is the registration of an individual cut string, with a double cut value. More...

	Selector ()
	Constructor clears the bits. More...

void	set (std::string const &s, bool val=true)
	Set a given selection cut, on or off. More...

void	set (index_type const &i, bool val=true)

void	set (std::string const &s, int cut, bool val=true)
	Set a given selection cut, on or off, and reset int cut value. More...

void	set (index_type const &i, int cut, bool val=true)

void	set (std::string const &s, double cut, bool val=true)
	Set a given selection cut, on or off, and reset int cut value. More...

void	set (index_type const &i, double cut, bool val=true)

void	setIgnored (pat::strbitset &ret)
	set ignored bits More...

void	setIgnoredCuts (std::vector< std::string > const &bitsToIgnore)
	set the bits to ignore from a vector More...

virtual	~Selector ()

Protected Attributes
std::vector< typename Selector < T >::index_type >	cut_indices_

std::vector< boost::shared_ptr < candf::CandidateCut > >	cuts_

unsigned	howfar_

bool	initialized_

std::vector< bool >	needs_event_content_

Protected Attributes inherited from Selector< T >
pat::strbitset	bits_
	the bitset indexed by strings More...

cut_flow_map	cutFlow_
	map of cut flows in "human" order More...

double_map	doubleCuts_
	the double-value cut map More...

int_map	intCuts_
	the int-value cut map More...

pat::strbitset	retInternal_
	internal ret if users don't care about return bits More...

Private Attributes
unsigned char	id_md5_ [MD5_DIGEST_LENGTH]

std::string	md5_string_

std::string	name_

Additional Inherited Members
Public Types inherited from Selector< T >
typedef std::binary_function < T, pat::strbitset, bool >	base_type

typedef std::pair< index_type, size_t >	cut_flow_item

typedef std::vector < cut_flow_item >	cut_flow_map

typedef T	data_type

typedef std::map< index_type, double >	double_map

typedef pat::strbitset::index_type	index_type

typedef std::map< index_type, int >	int_map

Detailed Description

template<class T>
class VersionedSelector< T >

cut-flow versioning info in the event provenance

class template to implement versioning for IDs that's available in the event provenance or available by hash-code in the event record

Author: Lindsey Gray

Definition at line 34 of file VersionedSelector.h.

Constructor & Destructor Documentation

template<class T>

VersionedSelector< T >::VersionedSelector ( )

inline

Definition at line 36 of file VersionedSelector.h.

36 : Selector<T>(), initialized_(false) {}

VersionedSelector::initialized_

bool initialized_

Definition: VersionedSelector.h:125

Selector

Functor that operates on <T>

Definition: Selector.h:24

template<class T>

VersionedSelector< T >::VersionedSelector ( const edm::ParameterSet & conf )

inline

Definition at line 38 of file VersionedSelector.h.

                                                 : 
   Selector<T>(),
   initialized_(false) { 
     constexpr unsigned length = MD5_DIGEST_LENGTH;
     edm::ParameterSet trackedPart = conf.trackedPart();
     name_ = conf.getParameter<std::string>("idName");
     memset(id_md5_,0,length*sizeof(unsigned char));
     std::string tracked(trackedPart.dump()), untracked(conf.dump());   
     if ( tracked != untracked ) {
       throw cms::Exception("InvalidConfiguration")
     << "VersionedSelector does not allow untracked parameters"
     << " in the configuration ParameterSet!";
     }
     // now setup the md5 and cute accessor functions
     MD5((unsigned char*)tracked.c_str(), tracked.size(), id_md5_);
     char buf[32];
     for( unsigned i=0; i<MD5_DIGEST_LENGTH; ++i ){
       sprintf(buf, "%02x", id_md5_[i]);
       md5_string_.append( buf );
     }
     initialize(conf);
     this->retInternal_  = this->getBitTemplate();
   }

Member Function Documentation

template<class T>

const size_t VersionedSelector< T >::cutFlowSize ( ) const

inline

Definition at line 116 of file VersionedSelector.h.

116 { return cuts_.size(); }

VersionedSelector::cuts_

std::vector< boost::shared_ptr< candf::CandidateCut > > cuts_

Definition: VersionedSelector.h:126

template<class T>

const unsigned VersionedSelector< T >::howFarInCutFlow ( ) const

inline

Definition at line 114 of file VersionedSelector.h.

114 { return howfar_; }

VersionedSelector::howfar_

unsigned howfar_

Definition: VersionedSelector.h:129

template<class T >

void VersionedSelector< T >::initialize ( const edm::ParameterSet & conf )

Definition at line 138 of file VersionedSelector.h.

References edm::hlt::Exception, reco::get(), edm::ParameterSet::getParameterSetVector(), mergeVDriftHistosByStation::name, fwrapper::plugin, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by VersionedSelector< edm::Ptr< reco::GsfElectron > >::VersionedSelector().

                                           {
   if(initialized_) {
     edm::LogWarning("VersionedPatElectronSelector")
       << "ID was already initialized!";
     return;
   }  
   const std::vector<edm::ParameterSet>& cutflow =
     conf.getParameterSetVector("cutFlow");  
   if( cutflow.size() == 0 ) {
     throw cms::Exception("InvalidCutFlow")
       << "You have supplied a null/empty cutflow to VersionedIDSelector,"
       << " please add content to the cuflow and try again.";
   }
   // this lets us keep track of cuts without knowing what they are :D
   std::vector<edm::ParameterSet>::const_iterator cbegin(cutflow.begin()),
     cend(cutflow.end());
   std::vector<edm::ParameterSet>::const_iterator icut = cbegin;
   for( ; icut != cend; ++icut ) {   
     const std::string& name = icut->getParameter<std::string>("cutName");
     const bool needsContent = 
       icut->getParameter<bool>("needsAdditionalProducts");     
     const bool ignored = icut->getParameter<bool>("isIgnored");
     candf::CandidateCut* plugin = 
 #if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
       CutApplicatorFactory::get()->create(name,*icut);
 #else
       nullptr;
 #endif
     if( plugin != nullptr ) {
       cuts_.push_back(boost::shared_ptr<candf::CandidateCut>(plugin));
     } else {
       throw cms::Exception("BadPluginName")
     << "The requested cut: " << name << " is not available!";
     }
     needs_event_content_.push_back(needsContent);
     this->push_back(name);
     this->set(name);
     if(ignored) this->ignoreCut(name);
   }    
   //have to loop again to set cut indices after all are filled
   icut = cbegin;
   for( ; icut != cend; ++icut ) {
     const std::string& name = icut->getParameter<std::string>("cutName");
     cut_indices_.push_back(typename Selector<T>::index_type(&(this->bits_),name));
   }
   initialized_ = true;
 }

template<class T>

const unsigned char* VersionedSelector< T >::md55Raw ( ) const

inline

Definition at line 105 of file VersionedSelector.h.

105 { return id_md5_; }

VersionedSelector::id_md5_

unsigned char id_md5_[MD5_DIGEST_LENGTH]

Definition: VersionedSelector.h:132

template<class T>

const std::string& VersionedSelector< T >::md5String ( ) const

inline

Definition at line 110 of file VersionedSelector.h.

110 { return md5_string_; }

VersionedSelector::md5_string_

std::string md5_string_

Definition: VersionedSelector.h:133

template<class T>

const std::string& VersionedSelector< T >::name ( void ) const

inline

Definition at line 112 of file VersionedSelector.h.

Referenced by cuy.divideElement::__init__(), cuy.plotElement::__init__(), cuy.additionElement::__init__(), cuy.superimposeElement::__init__(), and cuy.graphElement::__init__().

112 { return name_; }

VersionedSelector::name_

std::string name_

Definition: VersionedSelector.h:133

template<class T>

bool VersionedSelector< T >::operator()	(	const T &	t,
		pat::strbitset &	ret
	)

inlinefinaloverridevirtual

This provides the interface for base classes to select objects.

Implements Selector< T >.

Definition at line 62 of file VersionedSelector.h.

Referenced by VersionedSelector< edm::Ptr< reco::GsfElectron > >::operator()().

   {
     howfar_ = 0;
     bool failed = false;
     if( !initialized_ ) {
       throw cms::Exception("CutNotInitialized")
     << "VersionedGsfElectronSelector not initialized!" << std::endl;
     }  
     for( unsigned i = 0; i < cuts_.size(); ++i ) {
       reco::CandidatePtr temp(ref);
       const bool result = (*cuts_[i])(temp);
       if( result || this->ignoreCut(cut_indices_[i]) ) {
     this->passCut(ret,cut_indices_[i]);
     if( !failed ) ++howfar_;
       } else {
     failed = true;
       }
     }
     this->setIgnored(ret);
     return (bool)ret;
   }

template<class T>

bool VersionedSelector< T >::operator()	(	const T &	t,
		edm::EventBase const &	e,
		pat::strbitset &	ret
	)

inlinefinaloverridevirtual

This provides an alternative signature that includes extra information.

Reimplemented from Selector< T >.

Definition at line 87 of file VersionedSelector.h.

   {
     // setup isolation needs
     for( size_t i = 0, cutssize = cuts_.size(); i < cutssize; ++i ) {
       if( needs_event_content_[i] ) {
     CutApplicatorWithEventContentBase* needsEvent = 
       static_cast<CutApplicatorWithEventContentBase*>(cuts_[i].get());
     needsEvent->getEventContent(e);      
       }
     }
     return this->operator()(ref, ret);
   }

template<class T>

bool VersionedSelector< T >::operator== ( const VersionedSelector< T > & other ) const

inline

Definition at line 106 of file VersionedSelector.h.

                                                         {
     constexpr unsigned length = MD5_DIGEST_LENGTH;
     return ( 0 == memcmp(id_md5_,other.id_md5_,length*sizeof(unsigned char)) );
   }

template<class T >

void VersionedSelector< T >::setConsumes ( edm::ConsumesCollector cc )

Definition at line 189 of file VersionedSelector.h.

References i, and CutApplicatorWithEventContentBase::setConsumes().

                                                               {
   for( size_t i = 0, cutssize = cuts_.size(); i < cutssize; ++i ) {
     if( needs_event_content_[i] ) {
       CutApplicatorWithEventContentBase* needsEvent = 
     static_cast<CutApplicatorWithEventContentBase*>(cuts_[i].get());
       needsEvent->setConsumes(cc);
     }
   }
 }