| 1 |
dgele |
1.1 |
#ifndef RecoAlgos_TrackFullCloneSelectorBase_h
|
| 2 |
|
|
#define RecoAlgos_TrackFullCloneSelectorBase_h
|
| 3 |
|
|
/** \class TrackFullCloneSelectorBase
|
| 4 |
|
|
*
|
| 5 |
|
|
* selects a subset of a track collection, copying extra information on demand
|
| 6 |
|
|
*
|
| 7 |
|
|
* \author Giovanni Petrucciani
|
| 8 |
|
|
*
|
| 9 |
|
|
* \version $Revision: 1.1 $
|
| 10 |
|
|
*
|
| 11 |
|
|
* $Id: TrackFullCloneSelectorBase.h,v 1.1 2007/12/13 12:57:23 gpetrucc Exp $
|
| 12 |
|
|
*
|
| 13 |
|
|
*/
|
| 14 |
|
|
|
| 15 |
|
|
#include <utility>
|
| 16 |
|
|
#include <vector>
|
| 17 |
|
|
#include <memory>
|
| 18 |
|
|
#include <algorithm>
|
| 19 |
|
|
#include <map>
|
| 20 |
|
|
#include "FWCore/Framework/interface/EDProducer.h"
|
| 21 |
|
|
#include "FWCore/Framework/interface/EventPrincipal.h"
|
| 22 |
|
|
#include "FWCore/Framework/interface/Event.h"
|
| 23 |
|
|
#include "FWCore/ParameterSet/interface/ParameterSet.h"
|
| 24 |
|
|
#include "FWCore/ParameterSet/interface/InputTag.h"
|
| 25 |
|
|
|
| 26 |
|
|
#include "DataFormats/TrackReco/interface/TrackFwd.h"
|
| 27 |
|
|
#include "DataFormats/TrackReco/interface/Track.h"
|
| 28 |
|
|
#include "DataFormats/TrackReco/interface/TrackExtra.h"
|
| 29 |
|
|
#include "TrackingTools/PatternTools/interface/Trajectory.h"
|
| 30 |
|
|
#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
|
| 31 |
|
|
|
| 32 |
|
|
|
| 33 |
|
|
namespace reco { namespace modules {
|
| 34 |
|
|
|
| 35 |
|
|
template<typename Selector>
|
| 36 |
|
|
class TrackFullCloneSelectorBase : public edm::EDProducer {
|
| 37 |
|
|
public:
|
| 38 |
|
|
/// constructor
|
| 39 |
|
|
explicit TrackFullCloneSelectorBase( const edm::ParameterSet & cfg ) :
|
| 40 |
|
|
src_( cfg.template getParameter<edm::InputTag>( "src" ) ),
|
| 41 |
|
|
copyExtras_(cfg.template getUntrackedParameter<bool>("copyExtras", false)),
|
| 42 |
|
|
copyTrajectories_(cfg.template getUntrackedParameter<bool>("copyTrajectories", false)),
|
| 43 |
|
|
selector_( cfg ) {
|
| 44 |
|
|
std::string alias( cfg.getParameter<std::string>( "@module_label" ) );
|
| 45 |
|
|
produces<reco::TrackCollection>().setBranchAlias( alias + "Tracks" );
|
| 46 |
|
|
if (copyExtras_) {
|
| 47 |
|
|
produces<reco::TrackExtraCollection>().setBranchAlias( alias + "TrackExtras" );
|
| 48 |
|
|
produces<TrackingRecHitCollection>().setBranchAlias( alias + "RecHits" );
|
| 49 |
|
|
if (copyTrajectories_) {
|
| 50 |
|
|
produces< std::vector<Trajectory> >().setBranchAlias( alias + "Trajectories" );
|
| 51 |
|
|
produces< TrajTrackAssociationCollection >().setBranchAlias( alias + "TrajectoryTrackAssociations" );
|
| 52 |
|
|
}
|
| 53 |
|
|
}
|
| 54 |
|
|
}
|
| 55 |
|
|
/// destructor
|
| 56 |
|
|
virtual ~TrackFullCloneSelectorBase() { }
|
| 57 |
|
|
|
| 58 |
|
|
private:
|
| 59 |
|
|
/// process one event
|
| 60 |
|
|
void produce( edm::Event& evt, const edm::EventSetup& es ) {
|
| 61 |
|
|
edm::Handle<reco::TrackCollection> hSrcTrack;
|
| 62 |
|
|
edm::Handle< std::vector<Trajectory> > hTraj;
|
| 63 |
|
|
edm::Handle< TrajTrackAssociationCollection > hTTAss;
|
| 64 |
|
|
evt.getByLabel( src_, hSrcTrack );
|
| 65 |
|
|
|
| 66 |
|
|
selTracks_ = std::auto_ptr<reco::TrackCollection>(new reco::TrackCollection());
|
| 67 |
|
|
if (copyExtras_) {
|
| 68 |
|
|
selTrackExtras_ = std::auto_ptr<reco::TrackExtraCollection>(new reco::TrackExtraCollection());
|
| 69 |
|
|
selHits_ = std::auto_ptr<TrackingRecHitCollection>(new TrackingRecHitCollection());
|
| 70 |
|
|
}
|
| 71 |
|
|
|
| 72 |
|
|
TrackRefProd rTracks = evt.template getRefBeforePut<TrackCollection>();
|
| 73 |
|
|
|
| 74 |
|
|
TrackingRecHitRefProd rHits;
|
| 75 |
|
|
TrackExtraRefProd rTrackExtras;
|
| 76 |
|
|
if (copyExtras_) {
|
| 77 |
|
|
rHits = evt.template getRefBeforePut<TrackingRecHitCollection>();
|
| 78 |
|
|
rTrackExtras = evt.template getRefBeforePut<TrackExtraCollection>();
|
| 79 |
|
|
}
|
| 80 |
|
|
|
| 81 |
|
|
typedef reco::TrackRef::key_type TrackRefKey;
|
| 82 |
|
|
std::map<TrackRefKey, reco::TrackRef > goodTracks;
|
| 83 |
|
|
TrackRefKey current = 0;
|
| 84 |
|
|
|
| 85 |
|
|
for (reco::TrackCollection::const_iterator it = hSrcTrack->begin(), ed = hSrcTrack->end(); it != ed; ++it, ++current) {
|
| 86 |
|
|
const reco::Track & trk = * it;
|
| 87 |
|
|
if (!selector_(trk, evt)) continue;
|
| 88 |
|
|
|
| 89 |
|
|
selTracks_->push_back( Track( trk ) ); // clone and store
|
| 90 |
|
|
if (!copyExtras_) continue;
|
| 91 |
|
|
|
| 92 |
|
|
// TrackExtras
|
| 93 |
|
|
selTrackExtras_->push_back( TrackExtra( trk.outerPosition(), trk.outerMomentum(), trk.outerOk(),
|
| 94 |
|
|
trk.innerPosition(), trk.innerMomentum(), trk.innerOk(),
|
| 95 |
|
|
trk.outerStateCovariance(), trk.outerDetId(),
|
| 96 |
|
|
trk.innerStateCovariance(), trk.innerDetId(),
|
| 97 |
|
|
trk.seedDirection() ) );
|
| 98 |
|
|
selTracks_->back().setExtra( TrackExtraRef( rTrackExtras, selTrackExtras_->size() - 1) );
|
| 99 |
|
|
TrackExtra & tx = selTrackExtras_->back();
|
| 100 |
|
|
// TrackingRecHits
|
| 101 |
|
|
for( trackingRecHit_iterator hit = trk.recHitsBegin(); hit != trk.recHitsEnd(); ++ hit ) {
|
| 102 |
|
|
selHits_->push_back( (*hit)->clone() );
|
| 103 |
|
|
tx.add( TrackingRecHitRef( rHits, selHits_->size() - 1) );
|
| 104 |
|
|
}
|
| 105 |
|
|
if (copyTrajectories_) {
|
| 106 |
|
|
goodTracks[current] = reco::TrackRef(rTracks, selTracks_->size() - 1);
|
| 107 |
|
|
}
|
| 108 |
|
|
}
|
| 109 |
|
|
if ( copyTrajectories_ ) {
|
| 110 |
|
|
edm::Handle< std::vector<Trajectory> > hTraj;
|
| 111 |
|
|
edm::Handle< TrajTrackAssociationCollection > hTTAss;
|
| 112 |
|
|
evt.getByLabel(src_, hTTAss);
|
| 113 |
|
|
evt.getByLabel(src_, hTraj);
|
| 114 |
|
|
edm::RefProd< std::vector<Trajectory> > TrajRefProd = evt.template getRefBeforePut< std::vector<Trajectory> >();
|
| 115 |
|
|
selTrajs_ = std::auto_ptr< std::vector<Trajectory> >(new std::vector<Trajectory>());
|
| 116 |
|
|
selTTAss_ = std::auto_ptr< TrajTrackAssociationCollection >(new TrajTrackAssociationCollection());
|
| 117 |
|
|
for (size_t i = 0, n = hTraj->size(); i < n; ++i) {
|
| 118 |
|
|
edm::Ref< std::vector<Trajectory> > trajRef(hTraj, i);
|
| 119 |
|
|
TrajTrackAssociationCollection::const_iterator match = hTTAss->find(trajRef);
|
| 120 |
|
|
if (match != hTTAss->end()) {
|
| 121 |
|
|
const edm::Ref<reco::TrackCollection> &trkRef = match->val;
|
| 122 |
|
|
TrackRefKey oldKey = trkRef.key();
|
| 123 |
|
|
std::map<TrackRefKey, reco::TrackRef>::iterator getref = goodTracks.find(oldKey);
|
| 124 |
|
|
if (getref != goodTracks.end()) {
|
| 125 |
|
|
// do the clone
|
| 126 |
|
|
selTrajs_->push_back( Trajectory(*trajRef) );
|
| 127 |
|
|
selTTAss_->insert ( edm::Ref< std::vector<Trajectory> >(TrajRefProd, selTrajs_->size() - 1),
|
| 128 |
|
|
getref->second );
|
| 129 |
|
|
}
|
| 130 |
|
|
}
|
| 131 |
|
|
}
|
| 132 |
|
|
}
|
| 133 |
|
|
|
| 134 |
|
|
evt.put(selTracks_);
|
| 135 |
|
|
if (copyExtras_) {
|
| 136 |
|
|
evt.put(selTrackExtras_);
|
| 137 |
|
|
evt.put(selHits_);
|
| 138 |
|
|
if ( copyTrajectories_ ) {
|
| 139 |
|
|
evt.put(selTrajs_);
|
| 140 |
|
|
evt.put(selTTAss_);
|
| 141 |
|
|
}
|
| 142 |
|
|
}
|
| 143 |
|
|
}
|
| 144 |
|
|
/// source collection label
|
| 145 |
|
|
edm::InputTag src_;
|
| 146 |
|
|
/// copy only the tracks, not extras and rechits (for AOD)
|
| 147 |
|
|
bool copyExtras_;
|
| 148 |
|
|
/// copy also trajectories and trajectory->track associations
|
| 149 |
|
|
bool copyTrajectories_;
|
| 150 |
|
|
/// filter event
|
| 151 |
|
|
Selector selector_;
|
| 152 |
|
|
// some space
|
| 153 |
|
|
std::auto_ptr<reco::TrackCollection> selTracks_;
|
| 154 |
|
|
std::auto_ptr<reco::TrackExtraCollection> selTrackExtras_;
|
| 155 |
|
|
std::auto_ptr<TrackingRecHitCollection> selHits_;
|
| 156 |
|
|
std::auto_ptr< std::vector<Trajectory> > selTrajs_;
|
| 157 |
|
|
std::auto_ptr< TrajTrackAssociationCollection > selTTAss_;
|
| 158 |
|
|
};
|
| 159 |
|
|
|
| 160 |
|
|
} }
|
| 161 |
|
|
#endif
|
