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 BlockElementImporterBase &)=delete

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

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 11 of file GSFTrackImporter.cc.

Constructor & Destructor Documentation

◆ GSFTrackImporter()

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

inline

Definition at line 13 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

◆ importToBlock()

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

overridevirtual

Implements BlockElementImporterBase.

Definition at line 28 of file GSFTrackImporter.cc.

                                                                                                         {
   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::HGCalEE || scref->seed()->seed().det() == DetId::HGCalHSi ||
               scref->seed()->seed().det() == DetId::HGCalHSc || 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();
 }