#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.
std::vector< CandRefType >	all (const ParticleFilter &filter) const
	Return EDM references to all particles which satisfy some condition.
const_iterator	begin () const
size_t	count (const ParticleFilter &role) const
	Counts particles which satisfy some condition.
size_t	count () const
size_t	count (const std::string &roleRegexp) const
	Counts particles which have certaint roles.
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.
CandLooper	loop (const std::string &roleRegexp) const
	Loops over particles which have certaint roles.
CandLooper	loop (const ParticleFilter *filter) const
CandLooper	loop (const ParticleFilterPtr &filter) const
	Loops over particles which satisfy some condition.
CandLooper	loop (const ParticleFilter &filter) const
template<typename T >
eventhypothesis::Looper< T >	loopAs (const std::string &roleRegexp) const
	Loops over particles which have certaint roles.
template<typename T >
eventhypothesis::Looper< T >	loopAs (const ParticleFilterPtr &filter) const
	Loops over particles which satisfy some condition.
template<typename T >
eventhypothesis::Looper< T >	loopAs (const ParticleFilter *filter) const
template<typename T >
eventhypothesis::Looper< T >	loopAs (const ParticleFilter &filter) const
const CandRefType &	operator[] (const ParticleFilter &filter) const
const CandRefType &	operator[] (const std::string &role) const
const_reverse_iterator	rbegin () const
const_reverse_iterator	rend () const
Private Member Functions
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 26 of file EventHypothesis.h.

Member Typedef Documentation

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

Definition at line 33 of file EventHypothesis.h.

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

Definition at line 28 of file EventHypothesis.h.

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

Definition at line 31 of file EventHypothesis.h.

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

Definition at line 32 of file EventHypothesis.h.

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

Definition at line 50 of file EventHypothesis.h.

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

Definition at line 51 of file EventHypothesis.h.

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

Definition at line 29 of file EventHypothesis.h.

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

Definition at line 30 of file EventHypothesis.h.

Member Function Documentation

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

Definition at line 4 of file EventHypothesis.cc.

References particles_.

                                                                          {
    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 38 of file EventHypothesis.cc.

References cond::ecalcond::all.

{
    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 44 of file EventHypothesis.cc.

References begin, end, align_tpl::filter, and runTheMatrix::ret.

{
    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 37 of file EventHypothesis.h.

References particles_.

Referenced by pat::eventhypothesis::Looper< T >::globalIndex().

{ return particles_.begin(); }

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

Counts particles which satisfy some condition.

Definition at line 60 of file EventHypothesis.cc.

References begin, end, and n.

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

size_t pat::EventHypothesis::count ( void ) const [inline]

Definition at line 65 of file EventHypothesis.h.

References particles_.

{ return particles_.size(); }

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

Counts particles which have certaint roles.

Definition at line 54 of file EventHypothesis.cc.

References prof2calltree::count.

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

const_iterator pat::EventHypothesis::end ( void ) const [inline]

Definition at line 38 of file EventHypothesis.h.

References particles_.

{ return particles_.end();   }

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

Definition at line 9 of file EventHypothesis.cc.

References begin, end, and Exception.

{
    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 23 of file EventHypothesis.cc.

References begin, end, and Exception.

{
    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 138 of file EventHypothesis.h.

References Exception, edm::Ptr< T >::get(), getHLTprescales::index, mergeVDriftHistosByStation::name, and runTheMatrix::ret.

   {
       CandRefType ref = get(role, index);
       const T* ret = dynamic_cast<const T*>(ref.get());
       if ((ret == 0) && (ref.get() != 0)) throw cms::Exception("Type Checking") <<
                "You can't convert a " << typeid(*ref).name() << " to a " << typeid(T).name() << "\n" <<
                "note: you can use c++filt command to convert the above in human readable types.\n";
       return ret;
   }

template<typename T >

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

Definition at line 149 of file EventHypothesis.h.

References Exception, align_tpl::filter, edm::Ptr< T >::get(), getHLTprescales::index, mergeVDriftHistosByStation::name, and runTheMatrix::ret.

   {
       CandRefType ref = get(filter, index);
       const T* ret = dynamic_cast<const T*>(ref.get());
       if ((ret == 0) && (ref.get() != 0)) throw cms::Exception("Type Checking") <<
                "You can't convert a " << typeid(*ref).name() << " to a " << typeid(T).name() << "\n" <<
                "note: you can use c++filt command to convert the above in human readable types.\n";
       return ret;
   }

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

Loops over all particles.

Definition at line 70 of file EventHypothesis.cc.

References pat::eventhypothesis::AcceptAllFilter::get(), and loop().

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 76 of file EventHypothesis.cc.

References python::cmstools::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 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 88 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 94 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 caller code owns the filter, and must take care it is not deleted while the looper is still being used

Definition at line 82 of file EventHypothesis.cc.

{
    return CandLooper(*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 181 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 174 of file EventHypothesis.h.

   {
       return pat::eventhypothesis::Looper<T>(*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 160 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 167 of file EventHypothesis.h.

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

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

Definition at line 58 of file EventHypothesis.h.

References align_tpl::filter.

{ return get(filter,0); }

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

Definition at line 57 of file EventHypothesis.h.

{ return get(role,0); }

const_reverse_iterator pat::EventHypothesis::rbegin ( ) const [inline]

Definition at line 39 of file EventHypothesis.h.

References particles_.

{ return particles_.rbegin(); }

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 123 of file EventHypothesis.h.

   {
        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 40 of file EventHypothesis.h.

References particles_.

{ return particles_.rend();   }

Member Data Documentation

std::vector<value_type> pat::EventHypothesis::particles_ [private]

Definition at line 102 of file EventHypothesis.h.

Referenced by add(), begin(), count(), end(), rbegin(), and rend().

pat::EventHypothesis Class Reference

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Function Documentation

Member Data Documentation