Inheritance diagram for PFConversionProducer:

Public Member Functions
	PFConversionProducer (const edm::ParameterSet &)
	Constructor. More...

	~PFConversionProducer () override
	Destructor. More...

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
void	beginRun (const edm::Run &, const edm::EventSetup &) override

void	endRun (const edm::Run &, const edm::EventSetup &) override

void	produce (edm::Event &, const edm::EventSetup &) override
	Produce the PFRecTrack collection. More...

Private Attributes
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magneticFieldToken_

edm::EDGetTokenT< reco::ConversionCollection >	pfConversionContainer_

PFTrackTransformer *	pfTransformer_
	PFTrackTransformer. More...

const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	transientTrackToken_

edm::EDGetTokenT< reco::VertexCollection >	vtx_h

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 17 of file PFConversionProducer.cc.

Constructor & Destructor Documentation

◆ PFConversionProducer()

PFConversionProducer::PFConversionProducer ( const edm::ParameterSet & iConfig )

explicit

Constructor.

Definition at line 48 of file PFConversionProducer.cc.

     : pfTransformer_(nullptr),
       transientTrackToken_(esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))),
       magneticFieldToken_(esConsumes<edm::Transition::BeginRun>()) {
   produces<reco::PFRecTrackCollection>();
   produces<reco::PFConversionCollection>();
  
   pfConversionContainer_ = consumes<reco::ConversionCollection>(iConfig.getParameter<InputTag>("conversionCollection"));
  
   vtx_h = consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("PrimaryVertexLabel"));
 }

References edm::BeginRun, edm::ParameterSet::getParameter(), pfConversionContainer_, and vtx_h.

◆ ~PFConversionProducer()

PFConversionProducer::~PFConversionProducer ( )

override

Destructor.

Definition at line 60 of file PFConversionProducer.cc.

60 { delete pfTransformer_; }

References pfTransformer_.

Member Function Documentation

◆ beginRun()

void PFConversionProducer::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 197 of file PFConversionProducer.cc.

                                                                                {
   auto const& magneticField = &iSetup.getData(magneticFieldToken_);
   pfTransformer_ = new PFTrackTransformer(math::XYZVector(magneticField->inTesla(GlobalPoint(0, 0, 0))));
   pfTransformer_->OnlyProp();
 }

References edm::EventSetup::getData(), HLT_FULL_cff::magneticField, magneticFieldToken_, PFTrackTransformer::OnlyProp(), and pfTransformer_.

◆ endRun()

void PFConversionProducer::endRun	(	const edm::Run &	run,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 204 of file PFConversionProducer.cc.

                                                                              {
   delete pfTransformer_;
   pfTransformer_ = nullptr;
 }

References pfTransformer_.

◆ produce()

void PFConversionProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Produce the PFRecTrack collection.

Definition at line 62 of file PFConversionProducer.cc.

                                                                           {
   //create the empty collections
   auto pfConversionColl = std::make_unique<reco::PFConversionCollection>();
   auto pfRecTrackColl = std::make_unique<reco::PFRecTrackCollection>();
  
   TransientTrackBuilder const& thebuilder = iSetup.getData(transientTrackToken_);
  
   reco::PFRecTrackRefProd pfTrackRefProd = iEvent.getRefBeforePut<reco::PFRecTrackCollection>();
   Handle<reco::ConversionCollection> convCollH;
   iEvent.getByToken(pfConversionContainer_, convCollH);
  
   const reco::ConversionCollection& convColl = *(convCollH.product());
  
   Handle<reco::VertexCollection> vertex;
   iEvent.getByToken(vtx_h, vertex);
   //Find PV for IP calculation, if there is no PV in collection than use dummy
   reco::Vertex dummy;
   const reco::Vertex* pv = &dummy;
   if (vertex.isValid()) {
     pv = &*vertex->begin();
   } else {  // create a dummy PV
     reco::Vertex::Error e;
     e(0, 0) = 0.0015 * 0.0015;
     e(1, 1) = 0.0015 * 0.0015;
     e(2, 2) = 15. * 15.;
     reco::Vertex::Point p(0, 0, 0);
     dummy = reco::Vertex(p, e, 0, 0, 0);
   }
  
   int idx = 0;                                    //index of track in PFRecTrack collection
   multimap<unsigned int, unsigned int> trackmap;  //Map of Collections and tracks
   std::vector<unsigned int> conv_coll(0);
  
   // CLEAN CONVERSION COLLECTION FOR DUPLICATES
   for (unsigned int icoll1 = 0; icoll1 < convColl.size(); icoll1++) {
     if ((!convColl[icoll1].quality(reco::Conversion::arbitratedMergedEcalGeneral)) ||
         (!convColl[icoll1].quality(reco::Conversion::highPurity)))
       continue;
  
     bool greater_prob = false;
     std::vector<edm::RefToBase<reco::Track> > tracksRefColl1 = convColl[icoll1].tracks();
     for (unsigned it1 = 0; it1 < tracksRefColl1.size(); it1++) {
       reco::TrackRef trackRef1 = (tracksRefColl1[it1]).castTo<reco::TrackRef>();
  
       for (unsigned int icoll2 = 0; icoll2 < convColl.size(); icoll2++) {
         if (icoll1 == icoll2)
           continue;
         if ((!convColl[icoll2].quality(reco::Conversion::arbitratedMergedEcalGeneral)) ||
             (!convColl[icoll2].quality(reco::Conversion::highPurity)))
           continue;
         std::vector<edm::RefToBase<reco::Track> > tracksRefColl2 = convColl[icoll2].tracks();
         for (unsigned it2 = 0; it2 < tracksRefColl2.size(); it2++) {
           reco::TrackRef trackRef2 = (tracksRefColl2[it2]).castTo<reco::TrackRef>();
           double like1 = -999;
           double like2 = -999;
           //number of shared hits
           int shared = 0;
           for (auto const& hit1 : trackRef1->recHits())
             if (hit1->isValid()) {
               //count number of shared hits
               for (auto const& hit2 : trackRef2->recHits()) {
                 if (hit2->isValid() && hit1->sharesInput(hit2, TrackingRecHit::some))
                   shared++;
               }
             }
           float frac = 0;
           //number of valid hits in tracks that are duplicates
           float size1 = trackRef1->found();
           float size2 = trackRef2->found();
           //divide number of shared hits by the total number of hits for the track with less hits
           if (size1 > size2)
             frac = (double)shared / size2;
           else
             frac = (double)shared / size1;
           if (frac > 0.9) {
             like1 = ChiSquaredProbability(convColl[icoll1].conversionVertex().chi2(),
                                           convColl[icoll1].conversionVertex().ndof());
             like2 = ChiSquaredProbability(convColl[icoll2].conversionVertex().chi2(),
                                           convColl[icoll2].conversionVertex().ndof());
           }
           if (like2 > like1) {
             greater_prob = true;
             break;
           }
         }  //end loop over tracks in collection 2
  
         if (greater_prob)
           break;  //if a duplicate track is found in a collection with greater Chi^2 probability for Vertex fit then break out of comparison loop
       }           //end loop over collection 2 checking
       if (greater_prob)
         break;  //if a duplicate track is found in a collection with greater Chi^2 probability for Vertex fit then one does not need to check the other track the collection will not be stored
     }           //end loop over tracks in collection 1
     if (!greater_prob)
       conv_coll.push_back(icoll1);
   }  //end loop over collection 1
  
   //Finally fill empty collections
   for (unsigned iColl = 0; iColl < conv_coll.size(); iColl++) {
     unsigned int collindex = conv_coll[iColl];
     //std::cout<<"Filling this collection"<<collindex<<endl;
     std::vector<reco::PFRecTrackRef> pfRecTkcoll;
  
     std::vector<edm::RefToBase<reco::Track> > tracksRefColl = convColl[collindex].tracks();
     // convert the secondary tracks
     for (unsigned it = 0; it < tracksRefColl.size(); it++) {
       reco::TrackRef trackRef = (tracksRefColl[it]).castTo<reco::TrackRef>();
       reco::PFRecTrack pfRecTrack(trackRef->charge(), reco::PFRecTrack::KF, trackRef.key(), trackRef);
       //std::cout<<"Track Pt "<<trackRef->pt()<<std::endl;
       Trajectory FakeTraj;
       bool valid = pfTransformer_->addPoints(pfRecTrack, *trackRef, FakeTraj);
       if (valid) {
         double stip = -999;
         const reco::PFTrajectoryPoint& atECAL = pfRecTrack.extrapolatedPoint(reco::PFTrajectoryPoint::ECALEntrance);
         //if extrapolation to ECAL is valid then calculate STIP
         if (atECAL.isValid()) {
           GlobalVector direction(pfRecTrack.extrapolatedPoint(reco::PFTrajectoryPoint::ECALEntrance).position().x(),
                                  pfRecTrack.extrapolatedPoint(reco::PFTrajectoryPoint::ECALEntrance).position().y(),
                                  pfRecTrack.extrapolatedPoint(reco::PFTrajectoryPoint::ECALEntrance).position().z());
           stip = IPTools::signedTransverseImpactParameter(thebuilder.build(*trackRef), direction, *pv)
                      .second.significance();
         }
         pfRecTrack.setSTIP(stip);
         pfRecTkcoll.push_back(reco::PFRecTrackRef(pfTrackRefProd, idx++));
         pfRecTrackColl->push_back(pfRecTrack);
       }
     }  //end loop over tracks
     //store reference to the Conversion collection
     reco::ConversionRef niRef(convCollH, collindex);
     pfConversionColl->push_back(reco::PFConversion(niRef, pfRecTkcoll));
   }  //end loop over collections
   iEvent.put(std::move(pfRecTrackColl));
   iEvent.put(std::move(pfConversionColl));
 }