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

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

Inheritance diagram for VersionedSelector< T >:

Public Member Functions
const unsigned	bitMap () const

vid::CutFlowResult	cutFlowResult () const

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) final

bool	operator() (const T &ref, edm::EventBase const &e, pat::strbitset &ret) final

bool	operator() (typename T::value_type const &t)

bool	operator() (typename T::value_type const &t, edm::EventBase const &e)

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

bool	operator() (T const &t, edm::EventBase const &e) final
	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, pat::strbitset &ret)=0
	This provides the interface for base classes to select objects. More...

virtual bool	operator() (T const &t, edm::EventBase const &e, pat::strbitset &ret)
	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
unsigned	bitmap_

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

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

unsigned	howfar_

bool	initialized_

std::vector< bool >	needs_event_content_

std::vector< double >	values_

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...

Static Private Member Functions
static void	validateParamsAreTracked (const edm::ParameterSet &conf)

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::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 46 of file VersionedSelector.h.

Constructor & Destructor Documentation

template<class T>

VersionedSelector< T >::VersionedSelector ( )

inline

Definition at line 48 of file VersionedSelector.h.

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

VersionedSelector::initialized_

bool initialized_

Definition: VersionedSelector.h:183

Selector

Functor that operates on <T>

Definition: Selector.h:23

template<class T>

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

inline

Definition at line 50 of file VersionedSelector.h.

                                                 : 
   Selector<T>(),
   initialized_(false) { 
 
     validateParamsAreTracked(conf);
 
     name_ = conf.getParameter<std::string>("idName");
 
     // now setup the md5 and cute accessor functions
     constexpr unsigned length = MD5_DIGEST_LENGTH;
     std::string tracked(conf.trackedPart().dump());
     memset(id_md5_,0,length*sizeof(unsigned char));
     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 unsigned VersionedSelector< T >::bitMap ( ) const

inline

Definition at line 148 of file VersionedSelector.h.

148 { return bitmap_; }

VersionedSelector::bitmap_

unsigned bitmap_

Definition: VersionedSelector.h:187

template<class T >

vid::CutFlowResult VersionedSelector< T >::cutFlowResult ( ) const

Definition at line 255 of file VersionedSelector.h.

References training_settings::idx, dataset::name, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                            {
   std::map<std::string,unsigned> names_to_index;
   std::map<std::string,unsigned> cut_counter;
   for( unsigned idx = 0; idx < cuts_.size(); ++idx ) {
     const std::string& name = cuts_[idx]->name();
     if( !cut_counter.count(name) ) cut_counter[name] = 0;  
     std::stringstream realname;
     realname << name << "_" << cut_counter[name];
     names_to_index.emplace(realname.str(),idx);
     cut_counter[name]++;
   }
   return vid::CutFlowResult(name_,md5_string_,names_to_index,values_,bitmap_);
 }

template<class T>

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

inline

Definition at line 150 of file VersionedSelector.h.

150 { return cuts_.size(); }

VersionedSelector::cuts_

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

Definition: VersionedSelector.h:184

template<class T>

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

inline

Definition at line 146 of file VersionedSelector.h.

146 { return howfar_; }

VersionedSelector::howfar_

unsigned howfar_

Definition: VersionedSelector.h:187

template<class T >

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

Definition at line 197 of file VersionedSelector.h.

References CINT_GUARD, SoftLeptonByDistance_cfi::distance, Exception, reco::get(), edm::ParameterSet::getParameterSetVector(), dataset::name, and AlCaHLTBitMon_QueryRunRegistry::string.

                                           {
   if(initialized_) {
     edm::LogWarning("VersionedPatElectronSelector")
       << "ID was already initialized!";
     return;
   }  
   const std::vector<edm::ParameterSet>& cutflow =
     conf.getParameterSetVector("cutFlow");  
   if( cutflow.empty() ) {
     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;
   std::map<std::string,unsigned> cut_counter;
   std::vector<std::string> ignored_cuts;
   for( ; icut != cend; ++icut ) {  
     std::stringstream realname;    
     const std::string& name = icut->getParameter<std::string>("cutName");
     if( !cut_counter.count(name) ) cut_counter[name] = 0;      
     realname << name << "_" << cut_counter[name];
     const bool needsContent = 
       icut->getParameter<bool>("needsAdditionalProducts");     
     const bool ignored = icut->getParameter<bool>("isIgnored");
     CINT_GUARD(cuts_.emplace_back(CutApplicatorFactory::get()->create(name,*icut)));
     needs_event_content_.push_back(needsContent);
     const std::string therealname = realname.str();
     this->push_back(therealname);
     this->set(therealname);
     if(ignored) ignored_cuts.push_back(therealname);
     cut_counter[name]++;
   }    
   this->setIgnoredCuts(ignored_cuts);
 
   //have to loop again to set cut indices after all are filled
   icut = cbegin;
   cut_counter.clear();
   for( ; icut != cend; ++icut ) {
     std::stringstream realname;
     const std::string& name = cuts_[std::distance(cbegin,icut)]->name();    
     if( !cut_counter.count(name) ) cut_counter[name] = 0;      
     realname << name << "_" << cut_counter[name];
     cut_indices_.push_back(typename Selector<T>::index_type(&(this->bits_),realname.str()));    
     cut_counter[name]++;
   }
   
   initialized_ = true;
 }

template<class T>

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

inline

Definition at line 137 of file VersionedSelector.h.

137 { return id_md5_; }

VersionedSelector::id_md5_

unsigned char id_md5_[MD5_DIGEST_LENGTH]

Definition: VersionedSelector.h:191

template<class T>

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

inline

Definition at line 142 of file VersionedSelector.h.

Referenced by VIDSelectorBase.VIDSelectorBase::initialize().

142 { return md5_string_; }

VersionedSelector::md5_string_

std::string md5_string_

Definition: VersionedSelector.h:192

template<class T>

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

inline

Definition at line 144 of file VersionedSelector.h.

Referenced by config.CFG::__str__(), validation.Sample::digest(), and VIDSelectorBase.VIDSelectorBase::initialize().

144 { return name_; }

VersionedSelector::name_

std::string name_

Definition: VersionedSelector.h:192

template<class T>

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

inlinefinal

Definition at line 72 of file VersionedSelector.h.

                                                                        {
     howfar_ = 0;
     bitmap_ = 0;
     values_.clear();
     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);
       values_.push_back(cuts_[i]->value(temp));
       if( result || this->ignoreCut(cut_indices_[i]) ) {
     this->passCut(ret,cut_indices_[i]);
         bitmap_ |= 1<<i;
     if( !failed ) ++howfar_;
       } else {
     failed = true;
       }
     }
     this->setIgnored(ret);
     return (bool)ret;
   }

template<class T>

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

inlinefinal

Definition at line 97 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() ( typename T::value_type const & t )

inline

Definition at line 113 of file VersionedSelector.h.

                                                     {
     const T temp(&t,0); // assuming T is edm::Ptr
     return this->operator()(temp);
   }

template<class T>

bool VersionedSelector< T >::operator()	(	typename T::value_type const &	t,
		edm::EventBase const &	e
	)

inline

Definition at line 118 of file VersionedSelector.h.

                                                                            {
     const T temp(&t,0);
     return this->operator()(temp,e);
   }

template<class T>

bool VersionedSelector< T >::operator() ( T const & t )

inlinefinalvirtual

This provides an alternative signature without the second ret.

Reimplemented from Selector< T >.

Definition at line 123 of file VersionedSelector.h.

                                                    {
     this->retInternal_.set(false);
     this->operator()(t, this->retInternal_);
     this->setIgnored(this->retInternal_);
     return (bool)this->retInternal_;
   }

template<class T>

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

inlinefinalvirtual

This provides an alternative signature that includes extra information.

Reimplemented from Selector< T >.

Definition at line 130 of file VersionedSelector.h.

                                                                           {
     this->retInternal_.set(false);
     this->operator()(t, e, this->retInternal_);
     this->setIgnored(this->retInternal_);
     return (bool)this->retInternal_;
   }

template<class T>

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

inline

Definition at line 138 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 271 of file VersionedSelector.h.

References Exception, mps_fire::i, dataset::name, and CutApplicatorWithEventContentBase::setConsumes().

                                                               {
   for( size_t i = 0, cutssize = cuts_.size(); i < cutssize; ++i ) {
     if( needs_event_content_[i] ) {
       CutApplicatorWithEventContentBase* needsEvent = 
     dynamic_cast<CutApplicatorWithEventContentBase*>(cuts_[i].get());
       if( nullptr != needsEvent ) {
         needsEvent->setConsumes(cc);
       } else {
         throw cms::Exception("InvalidCutConfiguration")
           << "Cut: " << ((CutApplicatorBase*)cuts_[i].get())->name() 
           << " configured to consume event products but does not "
           << " inherit from CutApplicatorWithEventContenBase "
           << " please correct either your python or C++!";
       }
     }
   }
 }

template<class T>

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

inlinestaticprivate

Definition at line 166 of file VersionedSelector.h.

                                                                    {
     edm::ParameterSet trackedPart = conf.trackedPart();
     edm::ParameterSet confWithoutIsPOGApproved;
     for(auto& paraName : conf.getParameterNames()){
       if(paraName != "isPOGApproved") confWithoutIsPOGApproved.copyFrom(conf,paraName);
       else if(conf.existsAs<bool>(paraName,true)) confWithoutIsPOGApproved.copyFrom(conf,paraName); //adding isPOGApproved if its a tracked bool
     }
     std::string tracked(conf.trackedPart().dump()), untracked(confWithoutIsPOGApproved.dump());   
     if ( tracked != untracked ) {
       throw cms::Exception("InvalidConfiguration")
     << "VersionedSelector does not allow untracked parameters"
     << " in the cutflow ParameterSet!";
     }
   }

Member Data Documentation

template<class T>

unsigned VersionedSelector< T >::bitmap_

protected

Definition at line 187 of file VersionedSelector.h.

template<class T>

std::vector<typename Selector<T>::index_type> VersionedSelector< T >::cut_indices_

protected

Definition at line 186 of file VersionedSelector.h.

template<class T>

std::vector<std::shared_ptr< candf::CandidateCut > > VersionedSelector< T >::cuts_

protected

Definition at line 184 of file VersionedSelector.h.

template<class T>

unsigned VersionedSelector< T >::howfar_

protected

Definition at line 187 of file VersionedSelector.h.

template<class T>

unsigned char VersionedSelector< T >::id_md5_[MD5_DIGEST_LENGTH]

private

Definition at line 191 of file VersionedSelector.h.

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

template<class T>

bool VersionedSelector< T >::initialized_

protected

Definition at line 183 of file VersionedSelector.h.

template<class T>

std::string VersionedSelector< T >::md5_string_

private

Definition at line 192 of file VersionedSelector.h.

template<class T>

std::string VersionedSelector< T >::name_

private

Definition at line 192 of file VersionedSelector.h.

template<class T>

std::vector<bool> VersionedSelector< T >::needs_event_content_

protected

Definition at line 185 of file VersionedSelector.h.

template<class T>

std::vector<double> VersionedSelector< T >::values_

protected

Definition at line 188 of file VersionedSelector.h.

Public Member Functions

Protected Attributes

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<class T> class VersionedSelector< T >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class T>
class VersionedSelector< T >