TrackClassifierByProxy.h

Go to the documentation of this file.

 
#ifndef TrackClassifierByProxy_h
#define TrackClassifierByProxy_h
 
#include "DataFormats/Common/interface/AssociationMap.h"
 
#include "SimTracker/TrackHistory/interface/TrackClassifier.h"
 
template <typename Collection>
class TrackClassifierByProxy : public TrackClassifier
{
 
public:
 
    typedef edm::AssociationMap<edm::OneToMany<Collection, reco::TrackCollection> > Association;
 
    TrackClassifierByProxy(edm::ParameterSet const & config) : TrackClassifier(config),
            proxy_( config.getUntrackedParameter<edm::InputTag>("trackProducer") ) {}
 
    virtual void newEvent(edm::Event const & event, edm::EventSetup const & config)
    {
        // Get the association part of the proxy to the collection
        event.getByLabel(proxy_, proxyHandler_);
        // Call the previous new event
        TrackClassifier::newEvent(event, config);
    }
 
    TrackClassifierByProxy<Collection> const & evaluate (TrackingParticleRef const & track)
    {
        TrackClassifier::evaluate(track);
        return *this;
    }
 
    TrackClassifierByProxy<Collection> const & evaluate (edm::Ref<Collection> const & track, std::size_t index)
    {
        const reco::TrackRefVector * tracks = 0;
 
        try
        {
            // Get a reference to the vector of associated tracks
            tracks = proxyHandler_->find(track)->val;
        }
        catch (edm::Exception& e)
        {
            // If association fails define the track as unknown
            reset();
            unknownTrack();
            return *this;
        }
 
        // Evaluate the history for a given index
        TrackClassifier::evaluate( tracks->at(index) );
 
        return *this;
    }
 
    TrackClassifierByProxy<Collection> const & evaluate (edm::Ref<Collection> const & track)
    {
        const reco::TrackRefVector * tracks = 0;
 
        try
        {
            // Get a reference to the vector of associated tracks
            tracks = proxyHandler_->find(track)->val;
        }
        catch (edm::Exception& e)
        {
            // If association fails define the track as unknown
            reset();
            unknownTrack();
            return *this;
        }
 
        // Loop over all the associated tracks
        for (std::size_t index = 0; index < tracks->size(); ++index)
        {
            // Copy the last status for all the flags
            Flags flags(flags_);
 
            // Evaluate the history for a given index
            TrackClassifier::evaluate( tracks->at(index) );
 
            // Combine OR the flag information
            for (std::size_t i = 0; i < flags_.size(); ++i)
                flags_[i] = flags_[i] | flags[i];
        }
 
        return *this;
    }
 
private:
 
    const edm::InputTag proxy_;
 
    edm::Handle<Association> proxyHandler_;
 
};
 
#endif