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 &)

virtual	~BlockElementImporterBase ()=default

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.

References importToBlock().

                                          :
     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, SoftLeptonByDistance_cfi::distance, DetId::Forward, edm::Event::getHandle(), 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.

Referenced by GSFTrackImporter().

                                                               {
   auto gsftracks = e.getHandle(_src);
   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 auto& a){
                   return a->type() == reco::PFBlockElement::SC;
                 });
   // 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() ) {
       // explicitly veto HGCal super clusters
       if( scref->seed()->seed().det() == DetId::Forward ) continue;
       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.emplace(SCs_end,scbe);
         ++SCs_end; // point to element *after* the new one
       }
     }          
       }
     }// gsf extra ref?
     // cache the SC_end offset
     size_t 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;
     unsigned int IndexPout = 0;
     for(const auto& pfGsfPoint : PfGsfPoint) {      
       if (pfGsfPoint.isValid()){
     int layGsfP = pfGsfPoint.layer();
     if (layGsfP == -1) PassTracker = true;
     else if (PassTracker && layGsfP > 0) {
       IndexPout = c_gsf-1;
       break;
     }
     ++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();
 }