Inheritance diagram for GSFTrackImporter:

Public Member Functions
	GSFTrackImporter (const edm::ParameterSet &conf, edm::ConsumesCollector &sumes)

void	importToBlock (const edm::Event &, ElementList &) const override

Public Member Functions inherited from BlockElementImporterBase
	BlockElementImporterBase (const edm::ParameterSet &conf, edm::ConsumesCollector &sumes)

	BlockElementImporterBase (const BlockElementImporterBase &)=delete

const std::string &	name () const

BlockElementImporterBase &	operator= (const BlockElementImporterBase &)=delete

virtual void	updateEventSetup (const edm::EventSetup &)

Private Attributes
const bool	_isSecondary

edm::EDGetTokenT < reco::GsfPFRecTrackCollection >	_src

const bool	_superClustersArePF

Additional Inherited Members
Public Types inherited from BlockElementImporterBase
typedef std::vector < std::unique_ptr < reco::PFBlockElement > >	ElementList

Detailed Description

Definition at line 14 of file GSFTrackImporter.cc.

Constructor & Destructor Documentation

GSFTrackImporter::GSFTrackImporter	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &	sumes
	)

inline

Definition at line 16 of file GSFTrackImporter.cc.

                                          :
     BlockElementImporterBase(conf,sumes),
     _src(sumes.consumes<reco::GsfPFRecTrackCollection>(conf.getParameter<edm::InputTag>("source"))),
     _isSecondary(conf.getParameter<bool>("gsfsAreSecondary")),
     _superClustersArePF(conf.getParameter<bool>("superClustersArePF")){}

Member Function Documentation

void GSFTrackImporter::importToBlock	(	const edm::Event &	e,
		BlockElementImporterBase::ElementList &	elems
	)		const

overridevirtual

Implements BlockElementImporterBase.

Definition at line 36 of file GSFTrackImporter.cc.

References _isSecondary, _src, _superClustersArePF, a, HLT_25ns14e33_v1_cff::distance, edm::Event::getByToken(), edm::Ref< C, T, F >::isAvailable(), edm::Ref< C, T, F >::isNonnull(), reco::PFBlockElement::SC, reco::PFBlockElementSuperCluster::setFromGsfElectron(), reco::PFBlockElementSuperCluster::setFromPFSuperCluster(), reco::PFBlockElementGsfTrack::setTrackType(), reco::PFBlockElement::T_FROM_GAMMACONV, and groupFilesInBlocks::temp.

                                                               {
   typedef BlockElementImporterBase::ElementList::value_type ElementType;  
   edm::Handle<reco::GsfPFRecTrackCollection> gsftracks;
   e.getByToken(_src,gsftracks);
   elems.reserve(elems.size() + gsftracks->size());
   // setup our elements so that all the SCs are grouped together
   auto SCs_end = std::partition(elems.begin(),elems.end(),
                 [](const ElementType& a){
                   return a->type() == reco::PFBlockElement::SC;
                 });
   size_t SCs_end_position = std::distance(elems.begin(),SCs_end);
   // insert gsf tracks and SCs, binding pre-existing SCs to ECAL-Driven GSF
   auto bgsf = gsftracks->cbegin();
   auto egsf = gsftracks->cend();
   for( auto gsftrack =  bgsf; gsftrack != egsf; ++gsftrack ) {
     reco::GsfPFRecTrackRef gsfref(gsftracks,std::distance(bgsf,gsftrack));
     const reco::GsfTrackRef& basegsfref = gsftrack->gsfTrackRef();    
     const auto& gsfextraref = basegsfref->extra();
     // import associated super clusters
     if( gsfextraref.isAvailable() && gsfextraref->seedRef().isAvailable()) {
       reco::ElectronSeedRef seedref = 
     gsfextraref->seedRef().castTo<reco::ElectronSeedRef>();
       if( seedref.isAvailable() && seedref->isEcalDriven() ) {
     reco::SuperClusterRef scref = 
       seedref->caloCluster().castTo<reco::SuperClusterRef>();
     if( scref.isNonnull() ) {     
       PFBlockElementSCEqual myEqual(scref);
       auto sc_elem = std::find_if(elems.begin(),SCs_end,myEqual);
       if( sc_elem != SCs_end ) {
         reco::PFBlockElementSuperCluster* scbe = 
           static_cast<reco::PFBlockElementSuperCluster*>(sc_elem->get());
         scbe->setFromGsfElectron(true);
       } else {
         reco::PFBlockElementSuperCluster* scbe = 
           new reco::PFBlockElementSuperCluster(scref);
         scbe->setFromGsfElectron(true);
         scbe->setFromPFSuperCluster(_superClustersArePF);
         SCs_end = elems.insert(SCs_end,ElementType(scbe));
         ++SCs_end; // point to element *after* the new one
       }
     }   
       }
     }// gsf extra ref?
     // cache the SC_end offset
     SCs_end_position = std::distance(elems.begin(),SCs_end);
     // get track momentum information
     const std::vector<reco::PFTrajectoryPoint>& PfGsfPoint
       = gsftrack->trajectoryPoints();
     unsigned int c_gsf=0;
     bool PassTracker = false;
     bool GetPout = false;
     unsigned int IndexPout = 0;
     for(auto itPfGsfPoint =  PfGsfPoint.begin();  
     itPfGsfPoint!= PfGsfPoint.end();++itPfGsfPoint) {      
       if (itPfGsfPoint->isValid()){
     int layGsfP = itPfGsfPoint->layer();
     if (layGsfP == -1) PassTracker = true;
     if (PassTracker && layGsfP > 0 && GetPout == false) {
       IndexPout = c_gsf-1;
       GetPout = true;
     }
     //const math::XYZTLorentzVector GsfMoment = itPfGsfPoint->momentum();
     ++c_gsf;
       }
     }
     const math::XYZTLorentzVector& pin = PfGsfPoint[0].momentum();      
     const math::XYZTLorentzVector& pout = PfGsfPoint[IndexPout].momentum();
     reco::PFBlockElementGsfTrack* temp =
       new reco::PFBlockElementGsfTrack(gsfref,pin,pout);
     if( _isSecondary ) {
       temp->setTrackType(reco::PFBlockElement::T_FROM_GAMMACONV,true);
     }
     elems.emplace_back(temp);
     // import brems from this primary gsf
     for( const auto& brem : gsfref->PFRecBrem() ) {
       const unsigned TrajP = brem.indTrajPoint();
       if( TrajP != 99 ) {
     const double DP = brem.DeltaP();
     const double sDP = brem.SigmaDeltaP();
     elems.emplace_back(new reco::PFBlockElementBrem(gsfref,DP,sDP,TrajP));
       }
     }
     // protect against reallocations, create a fresh iterator
     SCs_end = elems.begin() + SCs_end_position;
   }// loop on gsf tracks
   elems.shrink_to_fit();
 }