#include <EventHypothesis.h>

Classes
class	ByRole

Public Types
typedef eventhypothesis::Looper< reco::Candidate >	CandLooper

typedef eventhypothesis::CandRefType	CandRefType

typedef vector_type::const_iterator	const_iterator

typedef vector_type::const_reverse_iterator	const_reverse_iterator

typedef eventhypothesis::ParticleFilter	ParticleFilter

typedef eventhypothesis::ParticleFilterPtr	ParticleFilterPtr

typedef std::pair< std::string, CandRefType >	value_type

typedef std::vector< value_type >	vector_type

Public Member Functions
void	add (const CandRefType &ref, const std::string &role)

std::vector< CandRefType >	all (const std::string &roleRegexp) const
	Return EDM references to all particles which have certaint roles. More...

std::vector< CandRefType >	all (const ParticleFilter &filter) const
	Return EDM references to all particles which satisfy some condition. More...

const_iterator	begin () const

size_t	count () const

size_t	count (const std::string &roleRegexp) const
	Counts particles which have certaint roles. More...

size_t	count (const ParticleFilter &role) const
	Counts particles which satisfy some condition. More...

const_iterator	end () const

const CandRefType &	get (const std::string &role, int index=0) const

const CandRefType &	get (const ParticleFilter &filter, int index=0) const

template<typename T >
const T *	getAs (const std::string &role, int index=0) const

template<typename T >
const T *	getAs (const ParticleFilter &filter, int index=0) const

CandLooper	loop () const
	Loops over all particles. More...

CandLooper	loop (const std::string &roleRegexp) const
	Loops over particles which have certaint roles. More...

CandLooper	loop (const ParticleFilter &filter) const

CandLooper	loop (const ParticleFilter *filter) const

CandLooper	loop (const ParticleFilterPtr &filter) const
	Loops over particles which satisfy some condition. More...

template<typename T >
eventhypothesis::Looper< T >	loopAs (const std::string &roleRegexp) const
	Loops over particles which have certaint roles. More...

template<typename T >
eventhypothesis::Looper< T >	loopAs (const ParticleFilter &filter) const

template<typename T >
eventhypothesis::Looper< T >	loopAs (const ParticleFilter *filter) const

template<typename T >
eventhypothesis::Looper< T >	loopAs (const ParticleFilterPtr &filter) const
	Loops over particles which satisfy some condition. More...

const CandRefType &	operator[] (const std::string &role) const

const CandRefType &	operator[] (const ParticleFilter &filter) const

const_reverse_iterator	rbegin () const

const_reverse_iterator	rend () const

Private Member Functions
template<typename T >
std::string	createExceptionMessage (const CandRefType &ref) const

char *	getDemangledSymbol (const char *mangledSymbol) const

template<typename Iterator , typename Predicate >
Iterator	realGet (const Iterator &realBegin, const Iterator &realEnd, const Predicate &p, size_t idx) const

Private Attributes
std::vector< value_type >	particles_

Detailed Description

Definition at line 30 of file EventHypothesis.h.

Member Typedef Documentation

typedef eventhypothesis::Looper<reco::Candidate> pat::EventHypothesis::CandLooper

Definition at line 37 of file EventHypothesis.h.

typedef eventhypothesis::CandRefType pat::EventHypothesis::CandRefType

Definition at line 32 of file EventHypothesis.h.

typedef vector_type::const_iterator pat::EventHypothesis::const_iterator

Definition at line 35 of file EventHypothesis.h.

typedef vector_type::const_reverse_iterator pat::EventHypothesis::const_reverse_iterator

Definition at line 36 of file EventHypothesis.h.

typedef eventhypothesis::ParticleFilter pat::EventHypothesis::ParticleFilter

Definition at line 54 of file EventHypothesis.h.

typedef eventhypothesis::ParticleFilterPtr pat::EventHypothesis::ParticleFilterPtr

Definition at line 55 of file EventHypothesis.h.

typedef std::pair<std::string, CandRefType> pat::EventHypothesis::value_type

Definition at line 33 of file EventHypothesis.h.

typedef std::vector<value_type> pat::EventHypothesis::vector_type

Definition at line 34 of file EventHypothesis.h.

Member Function Documentation

void pat::EventHypothesis::add	(	const CandRefType &	ref,
		const std::string &	role
	)

Definition at line 11 of file EventHypothesis.cc.

References particles_.

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                                           {
     particles_.push_back(value_type(role,ref));
 }

std::vector< pat::EventHypothesis::CandRefType > pat::EventHypothesis::all ( const std::string & roleRegexp ) const

Return EDM references to all particles which have certaint roles.

Definition at line 45 of file EventHypothesis.cc.

 {
     return all(pat::eventhypothesis::RoleRegexpFilter(roleRegexp));
 }

std::vector< pat::EventHypothesis::CandRefType > pat::EventHypothesis::all ( const ParticleFilter & filter ) const

Return EDM references to all particles which satisfy some condition.

Definition at line 51 of file EventHypothesis.cc.

References begin(), end(), and ALCARECOTkAlBeamHalo_cff::filter.

 {
     std::vector<pat::EventHypothesis::CandRefType> ret;
     for (const_iterator it = begin(); it != end(); ++it) {
         if (filter(*it)) ret.push_back(it->second);
     }
     return ret;
 }

const_iterator pat::EventHypothesis::begin ( void ) const

inline

Definition at line 41 of file EventHypothesis.h.

Referenced by all(), pat::eventhypothesis::Looper< T >::assertOk(), count(), pat::eventhypothesis::Looper< T >::first(), get(), pat::eventhypothesis::Looper< T >::operator bool(), pat::eventhypothesis::Looper< T >::operator--(), and pat::eventhypothesis::Looper< T >::realSize().

41 { return particles_.begin(); }

pat::EventHypothesis::particles_

std::vector< value_type > particles_

Definition: EventHypothesis.h:108

size_t pat::EventHypothesis::count ( void ) const

inline

Definition at line 69 of file EventHypothesis.h.

References KineDebug3::count(), training_settings::idx, heppy_loop::loop, AlCaHLTBitMon_ParallelJobs::p, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by count().

69 { return particles_.size(); }

pat::EventHypothesis::particles_

std::vector< value_type > particles_

Definition: EventHypothesis.h:108

size_t pat::EventHypothesis::count ( const std::string & roleRegexp ) const

Counts particles which have certaint roles.

Definition at line 61 of file EventHypothesis.cc.

References count().

 {
     return count(pat::eventhypothesis::RoleRegexpFilter(roleRegexp));
 }

size_t pat::EventHypothesis::count ( const ParticleFilter & role ) const

Counts particles which satisfy some condition.

Definition at line 67 of file EventHypothesis.cc.

References begin(), end(), and gen::n.

 {
     size_t n = 0;
     for (const_iterator it = begin(); it != end(); ++it) {
         if (role(*it)) ++n;
     }
     return n;
 }

template<typename T >

std::string pat::EventHypothesis::createExceptionMessage ( const CandRefType & ref ) const

private

Definition at line 147 of file EventHypothesis.h.

References dataset::name.

                                                                        {
      std::stringstream message;
      char *currentType = getDemangledSymbol(typeid(std::remove_reference<decltype(ref)>::type::value_type).name());
      char *targetType = getDemangledSymbol(typeid(T).name());
      if (currentType != nullptr && targetType != nullptr) {
        message << "You can't convert a '" << currentType << "' to a '" << targetType << "'" << std::endl;
        free(currentType);
        free(targetType);
      } else {
        message << "You can't convert a '" << typeid(ref).name() << "' to a '" << typeid(T).name() << "'" << std::endl;
        message << "Note: you can use 'c++filt -t' command to convert the above in human readable types." << std::endl;
      }
      return message.str();
    }

const_iterator pat::EventHypothesis::end ( void ) const

inline

Definition at line 42 of file EventHypothesis.h.

Referenced by all(), pat::eventhypothesis::Looper< T >::assertOk(), count(), Types.LuminosityBlockRange::cppID(), Types.EventRange::cppID(), pat::eventhypothesis::Looper< T >::first(), get(), pat::eventhypothesis::Looper< T >::operator bool(), pat::eventhypothesis::Looper< T >::operator++(), pat::eventhypothesis::Looper< T >::realSize(), and pat::eventhypothesis::Looper< T >::reset().

42 { return particles_.end(); }

pat::EventHypothesis::particles_

std::vector< value_type > particles_

Definition: EventHypothesis.h:108

const pat::EventHypothesis::CandRefType & pat::EventHypothesis::get	(	const std::string &	role,
		int	index = `0`
	)		const

Definition at line 16 of file EventHypothesis.cc.

References begin(), end(), Exception, rbegin(), realGet(), and rend().

 {
     if (index >= 0) {
         const_iterator it = realGet(begin(), end(), ByRole(role), index);
         if (it == end()) { throw cms::Exception("Index not found") << "Can't find a particle with role " << role << " and index " << index << "\n"; }
         return it->second;
     } else {
         const_reverse_iterator it = realGet(rbegin(), rend(), ByRole(role), -index);
         if (it == rend()) { throw cms::Exception("Index not found") << "Can't find a particle with role " << role << " and index " << index << "\n"; }
         return it->second;
     }
 }

const pat::EventHypothesis::CandRefType & pat::EventHypothesis::get	(	const ParticleFilter &	filter,
		int	index = `0`
	)		const

Definition at line 30 of file EventHypothesis.cc.

References begin(), end(), Exception, rbegin(), realGet(), and rend().

 {
     if (index >= 0) {
         const_iterator it = realGet(begin(), end(), filter, index);
         if (it == end()) { throw cms::Exception("Index not found") << "Can't find a particle matching filter with index " << index << "\n"; }
         return it->second;
     } else {
         const_reverse_iterator it = realGet(rbegin(), rend(), filter, -index);
         if (it == rend()) { throw cms::Exception("Index not found") << "Can't find a particle matching filter with index " << index << "\n"; }
         return it->second;
     }
 }

template<typename T >

const T * pat::EventHypothesis::getAs	(	const std::string &	role,
		int	index = `0`
	)		const

Definition at line 164 of file EventHypothesis.h.

References Exception, and edm::Ptr< T >::get().

    {
        CandRefType ref = get(role, index);
        const T* ret = dynamic_cast<const T*>(ref.get());
        if ((ret == 0) && (ref.get() != nullptr)) throw cms::Exception("Type Checking") << createExceptionMessage<T>(ref);
        return ret;
    }

template<typename T >

const T * pat::EventHypothesis::getAs	(	const ParticleFilter &	filter,
		int	index = `0`
	)		const

Definition at line 173 of file EventHypothesis.h.

References Exception, ALCARECOTkAlBeamHalo_cff::filter, and edm::Ptr< T >::get().

    {
        CandRefType ref = get(filter, index);
        const T* ret = dynamic_cast<const T*>(ref.get());
        if ((ret == 0) && (ref.get() != nullptr)) throw cms::Exception("Type Checking") << createExceptionMessage<T>(ref);
        return ret;
    }

char * pat::EventHypothesis::getDemangledSymbol ( const char * mangledSymbol ) const

private

Definition at line 5 of file EventHypothesis.cc.

References mps_update::status.

                                                                       {
     int status;
     char *demangledSymbol = abi::__cxa_demangle(mangledSymbol, nullptr, nullptr, &status);
     return (status == 0) ? demangledSymbol : nullptr;
 }

pat::EventHypothesis::CandLooper pat::EventHypothesis::loop ( ) const

Loops over all particles.

Definition at line 77 of file EventHypothesis.cc.

References pat::eventhypothesis::AcceptAllFilter::get().

Referenced by loop().

 {
     return loop(pat::eventhypothesis::AcceptAllFilter::get());
 }

pat::EventHypothesis::CandLooper pat::EventHypothesis::loop ( const std::string & roleRegexp ) const

Loops over particles which have certaint roles.

Definition at line 83 of file EventHypothesis.cc.

References loop().

 {
     return loop(new pat::eventhypothesis::RoleRegexpFilter(roleRegexp));
 }

pat::EventHypothesis::CandLooper pat::EventHypothesis::loop ( const ParticleFilter & filter ) const

Loops over particles which satisfy some condition. The caller code owns the filter, and must take care it is not deleted while the looper is still being used

Definition at line 89 of file EventHypothesis.cc.

 {
     return CandLooper(*this, role); 
 }

pat::EventHypothesis::CandLooper pat::EventHypothesis::loop ( const ParticleFilter * filter ) const

Loops over particles which satisfy some condition. The looper owns the filter, which will be deleted when the looper is deleted. That is, you can call eventHypothesis.loop(new WhateverFilterYouLike(...))

Definition at line 95 of file EventHypothesis.cc.

 {
     return CandLooper(*this, role); 
 }

pat::EventHypothesis::CandLooper pat::EventHypothesis::loop ( const ParticleFilterPtr & filter ) const

Loops over particles which satisfy some condition.

Definition at line 101 of file EventHypothesis.cc.

References pat::eventhypothesis::AcceptAllFilter::s_dummyFilter.

 {
     return CandLooper(*this, role); 
 }

template<typename T >

eventhypothesis::Looper< T > pat::EventHypothesis::loopAs ( const std::string & roleRegexp ) const

Loops over particles which have certaint roles.

Definition at line 182 of file EventHypothesis.h.

    {
        return loopAs<T>(new pat::eventhypothesis::RoleRegexpFilter(roleRegexp));
    }

template<typename T >

eventhypothesis::Looper< T > pat::EventHypothesis::loopAs ( const ParticleFilter & filter ) const

Loops over particles which satisfy some condition. The caller code owns the filter, and must take care it is not deleted while the looper is still being used

Definition at line 189 of file EventHypothesis.h.

    {
        return pat::eventhypothesis::Looper<T>(*this, role);
    }

template<typename T >

eventhypothesis::Looper< T > pat::EventHypothesis::loopAs ( const ParticleFilter * filter ) const

Loops over particles which satisfy some condition. The looper owns the filter, which will be deleted when the looper is deleted. That is, you can call eventHypothesis.loopAs<...>(new WhateverFilterYouLike(...))

Definition at line 196 of file EventHypothesis.h.

    {
        return pat::eventhypothesis::Looper<T>(*this, role);
    }

template<typename T >

eventhypothesis::Looper< T > pat::EventHypothesis::loopAs ( const ParticleFilterPtr & filter ) const

Loops over particles which satisfy some condition.

Definition at line 203 of file EventHypothesis.h.

    {
        return pat::eventhypothesis::Looper<T>(*this, role);
    }

const CandRefType& pat::EventHypothesis::operator[] ( const std::string & role ) const

inline

Definition at line 61 of file EventHypothesis.h.

61 { return get(role,0); }

const CandRefType& pat::EventHypothesis::operator[] ( const ParticleFilter & filter ) const

inline

Definition at line 62 of file EventHypothesis.h.

References Vispa.Plugins.EdmBrowser.EdmDataAccessor::all(), ALCARECOTkAlBeamHalo_cff::filter, and AlCaHLTBitMon_QueryRunRegistry::string.

62 { return get(filter,0); }

ALCARECOTkAlBeamHalo_cff.filter

filter

Definition: ALCARECOTkAlBeamHalo_cff.py:27

const_reverse_iterator pat::EventHypothesis::rbegin ( ) const

inline

Definition at line 43 of file EventHypothesis.h.

Referenced by get().

43 { return particles_.rbegin(); }

pat::EventHypothesis::particles_

std::vector< value_type > particles_

Definition: EventHypothesis.h:108

template<typename Iterator , typename Predicate >

Iterator pat::EventHypothesis::realGet	(	const Iterator &	realBegin,
		const Iterator &	realEnd,
		const Predicate &	p,
		size_t	idx
	)		const

private

Definition at line 132 of file EventHypothesis.h.

References AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by get().

    {
         Iterator it = realBegin;
         while (it != realEnd) {
             if (pred(*it)) {
                 if (idx == 0) return it;
                 idx--;
             }
             ++it;
         }
         return it;
    }

const_reverse_iterator pat::EventHypothesis::rend ( ) const

inline

Definition at line 44 of file EventHypothesis.h.

Referenced by get().

44 { return particles_.rend(); }

pat::EventHypothesis::particles_

std::vector< value_type > particles_

Definition: EventHypothesis.h:108

Member Data Documentation

std::vector<value_type> pat::EventHypothesis::particles_

private

Definition at line 108 of file EventHypothesis.h.

Referenced by add().

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Function Documentation

Member Data Documentation