Inheritance diagram for ConversionProducer:

Public Member Functions
	ConversionProducer (const edm::ParameterSet &)

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 Types
typedef math::XYZPointF	Point

typedef std::vector< Point >	PointCollection

Private Member Functions
void	buildCollection (edm::Event &iEvent, const edm::EventSetup &iSetup, const std::multimap< float, edm::Ptr< reco::ConversionTrack > > &allTracks, const std::multimap< double, reco::CaloClusterPtr > &superClusterPtrs, const std::multimap< double, reco::CaloClusterPtr > &basicClusterPtrs, const reco::Vertex &the_pvtx, reco::ConversionCollection &outputConvPhotonCollection)

void	buildSuperAndBasicClusterGeoMap (const edm::Event &, std::multimap< double, reco::CaloClusterPtr > &basicClusterPtrs, std::multimap< double, reco::CaloClusterPtr > &superClusterPtrs)

bool	checkPhi (const edm::RefToBase< reco::Track > &tk_l, const edm::RefToBase< reco::Track > &tk_r, TrackerGeometry const &trackerGeom, MagneticField const &magField, const reco::Vertex &the_vertex)

bool	checkTrackPair (const std::pair< edm::RefToBase< reco::Track >, reco::CaloClusterPtr > &ll, const std::pair< edm::RefToBase< reco::Track >, reco::CaloClusterPtr > &rr)

bool	checkVertex (const reco::TransientTrack &ttk_l, const reco::TransientTrack &ttk_r, MagneticField const &magField, reco::Vertex &the_vertex)

double	etaTransformation (float EtaParticle, float Zvertex)

bool	getMatchedBC (const std::multimap< double, reco::CaloClusterPtr > &bcMap, const math::XYZPointF &trackImpactPosition, reco::CaloClusterPtr &closestBC)

bool	getTrackImpactPosition (const reco::Track *tk_ref, TrackerGeometry const &trackerGeom, MagneticField const &magField, math::XYZPointF &ew)

bool	matchingSC (const std::multimap< double, reco::CaloClusterPtr > &scMap, reco::Conversion &conv, reco::CaloClusterPtrVector &mSC)

bool	preselectTrackPair (const reco::TransientTrack &ttk_l, const reco::TransientTrack &ttk_r, double &appDist)

void	produce (edm::Event &, const edm::EventSetup &) override

math::XYZPointF	toFConverterP (const math::XYZPoint &val)

math::XYZVectorF	toFConverterV (const math::XYZVector &val)

bool	trackD0Cut (const edm::RefToBase< reco::Track > &ref)

bool	trackD0Cut (const edm::RefToBase< reco::Track > &ref, const reco::Vertex &the_pvtx)

bool	trackQualityFilter (const edm::RefToBase< reco::Track > &ref, bool isLeft)

Private Attributes
std::string	algoName_

bool	allowD0_

bool	allowDeltaCot_

bool	allowDeltaPhi_

bool	allowMinApproach_

bool	allowOppCharge_

bool	allowSingleLeg_

bool	allowTrackBC_

bool	allowVertex_

edm::EDGetTokenT< edm::View< reco::CaloCluster > >	bcBarrelCollection_

edm::EDGetTokenT< edm::View< reco::CaloCluster > >	bcEndcapCollection_

bool	bypassPreselEcal_

bool	bypassPreselEcalEcal_

bool	bypassPreselGsf_

std::string	ConvertedPhotonCollection_

double	d0Cut_

double	deltaCotTheta_

double	deltaEta_

double	deltaPhi_

double	dEtacutForSCmatching_

double	dEtaTkBC_

double	dPhicutForSCmatching_

double	dPhiTkBC_

double	dzCut_

double	energyBC_

double	energyTotalBC_

double	halfWayEta_

double	halfWayPhi_

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magneticField_

double	maxChi2Left_

double	maxChi2Right_

unsigned int	maxNumOfTrackInPU_

double	maxTrackRho_

double	maxTrackZ_

double	minApproachHigh_

double	minApproachLow_

double	minHitsLeft_

double	minHitsRight_

double	minSCEt_

double	r_cut

bool	rightBC_

edm::EDGetTokenT< edm::View< reco::CaloCluster > >	scBarrelProducer_

edm::EDGetTokenT< edm::View< reco::CaloCluster > >	scEndcapProducer_

edm::EDGetTokenT< edm::View< reco::ConversionTrack > >	src_

const TransientTrackBuilder *	thettbuilder_

edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	trackerGeometry_

edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	transientTrackBuilder_

bool	usePvtx_

ConversionVertexFinder	vertexFinder_

edm::EDGetTokenT< reco::VertexCollection >	vertexProducer_

double	vtxChi2_

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

Description: Produces converted photon objects using default track collections

Implementation: <Notes on="" implementation>="">

Definition at line 65 of file ConversionProducer.cc.

Member Typedef Documentation

◆ Point

typedef math::XYZPointF ConversionProducer::Point

private

Definition at line 79 of file ConversionProducer.cc.

◆ PointCollection

typedef std::vector<Point> ConversionProducer::PointCollection

private

Definition at line 80 of file ConversionProducer.cc.

Constructor & Destructor Documentation

◆ ConversionProducer()

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

explicit

Definition at line 206 of file ConversionProducer.cc.

                                                                      : vertexFinder_{iConfig} {
   algoName_ = iConfig.getParameter<std::string>("AlgorithmName");
 
   src_ = consumes<edm::View<reco::ConversionTrack> >(iConfig.getParameter<edm::InputTag>("src"));
 
   maxNumOfTrackInPU_ = iConfig.getParameter<int>("maxNumOfTrackInPU");
   maxTrackRho_ = iConfig.getParameter<double>("maxTrackRho");
   maxTrackZ_ = iConfig.getParameter<double>("maxTrackZ");
 
   allowTrackBC_ = iConfig.getParameter<bool>("AllowTrackBC");
   allowD0_ = iConfig.getParameter<bool>("AllowD0");
   allowDeltaPhi_ = iConfig.getParameter<bool>("AllowDeltaPhi");
   allowDeltaCot_ = iConfig.getParameter<bool>("AllowDeltaCot");
   allowMinApproach_ = iConfig.getParameter<bool>("AllowMinApproach");
   allowOppCharge_ = iConfig.getParameter<bool>("AllowOppCharge");
 
   allowVertex_ = iConfig.getParameter<bool>("AllowVertex");
 
   bypassPreselGsf_ = iConfig.getParameter<bool>("bypassPreselGsf");
   bypassPreselEcal_ = iConfig.getParameter<bool>("bypassPreselEcal");
   bypassPreselEcalEcal_ = iConfig.getParameter<bool>("bypassPreselEcalEcal");
 
   deltaEta_ = iConfig.getParameter<double>("deltaEta");
 
   halfWayEta_ = iConfig.getParameter<double>("HalfwayEta");  //open angle to search track matches with BC
 
   d0Cut_ = iConfig.getParameter<double>("d0");
 
   usePvtx_ = iConfig.getParameter<bool>("UsePvtx");  //if use primary vertices
 
   vertexProducer_ = consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("primaryVertexProducer"));
 
   transientTrackBuilder_ = esConsumes(edm::ESInputTag("", "TransientTrackBuilder"));
   trackerGeometry_ = esConsumes();
   magneticField_ = esConsumes();
 
   //Track-cluster matching eta and phi cuts
   dEtaTkBC_ = iConfig.getParameter<double>("dEtaTrackBC");  //TODO research on cut endcap/barrel
   dPhiTkBC_ = iConfig.getParameter<double>("dPhiTrackBC");
 
   bcBarrelCollection_ =
       consumes<edm::View<reco::CaloCluster> >(iConfig.getParameter<edm::InputTag>("bcBarrelCollection"));
   bcEndcapCollection_ =
       consumes<edm::View<reco::CaloCluster> >(iConfig.getParameter<edm::InputTag>("bcEndcapCollection"));
 
   scBarrelProducer_ = consumes<edm::View<reco::CaloCluster> >(iConfig.getParameter<edm::InputTag>("scBarrelProducer"));
   scEndcapProducer_ = consumes<edm::View<reco::CaloCluster> >(iConfig.getParameter<edm::InputTag>("scEndcapProducer"));
 
   energyBC_ = iConfig.getParameter<double>("EnergyBC");            //BC energy threshold
   energyTotalBC_ = iConfig.getParameter<double>("EnergyTotalBC");  //BC energy threshold
   minSCEt_ = iConfig.getParameter<double>("minSCEt");              //super cluster energy threshold
   dEtacutForSCmatching_ = iConfig.getParameter<double>(
       "dEtacutForSCmatching");  // dEta between conversion momentum direction and SC position
   dPhicutForSCmatching_ = iConfig.getParameter<double>(
       "dPhicutForSCmatching");  // dPhi between conversion momentum direction and SC position
 
   //Track cuts on left right track: at least one leg reaches ECAL
   //Left track: must exist, must reach Ecal and match BC, so loose cut on Chi2 and tight on hits
   //Right track: not necessary to exist (if allowSingleLeg_), not necessary to reach ECAL or match BC, so tight cut on Chi2 and loose on hits
   maxChi2Left_ = iConfig.getParameter<double>("MaxChi2Left");
   maxChi2Right_ = iConfig.getParameter<double>("MaxChi2Right");
   minHitsLeft_ = iConfig.getParameter<int>("MinHitsLeft");
   minHitsRight_ = iConfig.getParameter<int>("MinHitsRight");
 
   //Track Open angle cut on delta cot(theta) and delta phi
   deltaCotTheta_ = iConfig.getParameter<double>("DeltaCotTheta");
   deltaPhi_ = iConfig.getParameter<double>("DeltaPhi");
   minApproachLow_ = iConfig.getParameter<double>("MinApproachLow");
   minApproachHigh_ = iConfig.getParameter<double>("MinApproachHigh");
 
   // if allow single track collection, by default False
   allowSingleLeg_ = iConfig.getParameter<bool>("AllowSingleLeg");
   rightBC_ = iConfig.getParameter<bool>("AllowRightBC");
 
   //track inner position dz cut, need RECO
   dzCut_ = iConfig.getParameter<double>("dz");
   //track analytical cross cut
   r_cut = iConfig.getParameter<double>("rCut");
   vtxChi2_ = iConfig.getParameter<double>("vtxChi2");
 
   thettbuilder_ = nullptr;
 
   //output
   ConvertedPhotonCollection_ = iConfig.getParameter<std::string>("convertedPhotonCollection");
 
   produces<reco::ConversionCollection>(ConvertedPhotonCollection_);
 }

Member Function Documentation

◆ buildCollection()

void ConversionProducer::buildCollection	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const std::multimap< float, edm::Ptr< reco::ConversionTrack > > &	allTracks,
		const std::multimap< double, reco::CaloClusterPtr > &	superClusterPtrs,
		const std::multimap< double, reco::CaloClusterPtr > &	basicClusterPtrs,
		const reco::Vertex &	the_pvtx,
		reco::ConversionCollection &	outputConvPhotonCollection
	)

private

match the track pair with a SC. If at least one track matches, store the SC

Definition at line 404 of file ConversionProducer.cc.

Referenced by produce().

                                                                                                {
   TrackerGeometry const& trackerGeom = iSetup.getData(trackerGeometry_);
   MagneticField const& magField = iSetup.getData(magneticField_);
 
   //   std::vector<math::XYZPointF> trackImpactPosition;
   //   trackImpactPosition.reserve(allTracks.size());//track impact position at ECAL
   //   std::vector<bool> trackValidECAL;//Does this track reach ECAL basic cluster (reach ECAL && match with BC)
   //   trackValidECAL.assign(allTracks.size(), false);
   //
   //   std::vector<reco::CaloClusterPtr> trackMatchedBC;
   //   reco::CaloClusterPtr empty_bc;
   //   trackMatchedBC.assign(allTracks.size(), empty_bc);//TODO find a better way to avoid copy constructor
   //
   //   std::vector<int> bcHandleId;//the associated BC handle id, -1 invalid, 0 barrel 1 endcap
   //   bcHandleId.assign(allTracks.size(), -1);
 
   // not used    std::multimap<double, int> trackInnerEta;//Track innermost state Eta map to TrackRef index, to be used in track pair sorting
 
   std::map<edm::Ptr<reco::ConversionTrack>, math::XYZPointF> trackImpactPosition;
   std::map<edm::Ptr<reco::ConversionTrack>, reco::CaloClusterPtr> trackMatchedBC;
 
   ConversionHitChecker hitChecker;
 
   //2 propagate all tracks into ECAL, record its eta and phi
 
   for (auto const& tk_ref : allTracks) {
     const reco::Track* tk = tk_ref.second->trackRef().get();
 
     //check impact position then match with BC
     math::XYZPointF ew;
     if (getTrackImpactPosition(tk, trackerGeom, magField, ew)) {
       trackImpactPosition[tk_ref.second] = ew;
 
       reco::CaloClusterPtr closest_bc;  //the closest matching BC to track
 
       if (getMatchedBC(basicClusterPtrs, ew, closest_bc)) {
         trackMatchedBC[tk_ref.second] = closest_bc;
       }
     }
   }
 
   //3. pair up tracks:
   //TODO it is k-Closest pair of point problem
   //std::cout << " allTracks.size() " <<  allTracks.size() << std::endl;
   for (auto ll = allTracks.begin(); ll != allTracks.end(); ++ll) {
     bool track1HighPurity = true;
     //std::cout << " Loop on allTracks " << std::endl;
     const edm::RefToBase<reco::Track>& left = ll->second->trackRef();
 
     //TODO: This is a workaround, should be fixed with a proper function in the TTBuilder
     //(Note that the TrackRef and GsfTrackRef versions of the constructor are needed
     // to properly get refit tracks in the output vertex)
     reco::TransientTrack ttk_l;
     if (dynamic_cast<const reco::GsfTrack*>(left.get())) {
       ttk_l = thettbuilder_->build(left.castTo<reco::GsfTrackRef>());
     } else {
       ttk_l = thettbuilder_->build(left.castTo<reco::TrackRef>());
     }
 
     //      if ((allowTrackBC_ && !trackValidECAL[ll-allTracks.begin()]) )//this Left leg should have valid BC
     // continue;
 
     if (the_pvtx.isValid()) {
       if (!(trackD0Cut(left, the_pvtx)))
         track1HighPurity = false;
     } else {
       if (!(trackD0Cut(left)))
         track1HighPurity = false;
     }
 
     std::vector<int> right_candidates;  //store all right legs passed the cut (theta/approach and ref pair)
     std::vector<double> right_candidate_theta, right_candidate_approach;
     std::vector<std::pair<bool, reco::Vertex> > vertex_candidates;
 
     //inner loop only over tracks between eta and eta + deltaEta of the first track
     float etasearch = ll->first + deltaEta_;
     std::multimap<float, edm::Ptr<reco::ConversionTrack> >::const_iterator rr = ll;
     ++rr;
     for (; rr != allTracks.lower_bound(etasearch); ++rr) {
       bool track2HighPurity = true;
       bool highPurityPair = true;
 
       const edm::RefToBase<reco::Track>& right = rr->second->trackRef();
 
       //TODO: This is a workaround, should be fixed with a proper function in the TTBuilder
       reco::TransientTrack ttk_r;
       if (dynamic_cast<const reco::GsfTrack*>(right.get())) {
         ttk_r = thettbuilder_->build(right.castTo<reco::GsfTrackRef>());
       } else {
         ttk_r = thettbuilder_->build(right.castTo<reco::TrackRef>());
       }
       //std::cout << " This track is " <<  right->algoName() << std::endl;
 
       //all vertexing preselection should go here
 
       //check for opposite charge
       if (allowOppCharge_ && (left->charge() * right->charge() > 0))
         continue;  //same sign, reject pair
 
       //if ( (allowTrackBC_ && !trackValidECAL[rr-allTracks.begin()] && rightBC_) )// if right track matches ECAL
       //  continue;
 
       double approachDist = -999.;
       //apply preselection to track pair, overriding preselection for gsf+X or ecalseeded+X pairs if so configured
       bool preselected = preselectTrackPair(ttk_l, ttk_r, approachDist);
       preselected = preselected || (bypassPreselGsf_ &&
                                     (left->algo() == reco::TrackBase::gsf || right->algo() == reco::TrackBase::gsf));
       preselected = preselected || (bypassPreselEcal_ && (left->algo() == reco::TrackBase::outInEcalSeededConv ||
                                                           right->algo() == reco::TrackBase::outInEcalSeededConv ||
                                                           left->algo() == reco::TrackBase::inOutEcalSeededConv ||
                                                           right->algo() == reco::TrackBase::inOutEcalSeededConv));
       preselected = preselected || (bypassPreselEcalEcal_ &&
                                     (left->algo() == reco::TrackBase::outInEcalSeededConv ||
                                      left->algo() == reco::TrackBase::inOutEcalSeededConv) &&
                                     (right->algo() == reco::TrackBase::outInEcalSeededConv ||
                                      right->algo() == reco::TrackBase::inOutEcalSeededConv));
 
       if (!preselected) {
         continue;
       }
 
       //do the actual vertex fit
       reco::Vertex theConversionVertex;  //by default it is invalid
       bool goodVertex = checkVertex(ttk_l, ttk_r, magField, theConversionVertex);
 
       //bail as early as possible in case the fit didn't return a good vertex
       if (!goodVertex) {
         continue;
       }
 
       //track pair pass the quality cut
       if (!((trackQualityFilter(left, true) && trackQualityFilter(right, false)) ||
             (trackQualityFilter(left, false) && trackQualityFilter(right, true)))) {
         highPurityPair = false;
       }
 
       if (the_pvtx.isValid()) {
         if (!(trackD0Cut(right, the_pvtx)))
           track2HighPurity = false;
       } else {
         if (!(trackD0Cut(right)))
           track2HighPurity = false;
       }
 
       //if all cuts passed, go ahead to make conversion candidates
       std::vector<edm::RefToBase<reco::Track> > trackPairRef;
       trackPairRef.push_back(left);   //left track
       trackPairRef.push_back(right);  //right track
 
       std::vector<math::XYZVectorF> trackPin;
       std::vector<math::XYZVectorF> trackPout;
       std::vector<math::XYZPointF> trackInnPos;
       std::vector<uint8_t> nHitsBeforeVtx;
       std::vector<Measurement1DFloat> dlClosestHitToVtx;
 
       if (left->extra().isNonnull() && right->extra().isNonnull()) {  //only available on TrackExtra
         trackInnPos.push_back(toFConverterP(left->innerPosition()));
         trackInnPos.push_back(toFConverterP(right->innerPosition()));
         trackPin.push_back(toFConverterV(left->innerMomentum()));
         trackPin.push_back(toFConverterV(right->innerMomentum()));
         trackPout.push_back(toFConverterV(left->outerMomentum()));
         trackPout.push_back(toFConverterV(right->outerMomentum()));
         auto leftWrongHits = hitChecker.nHitsBeforeVtx(*left->extra(), theConversionVertex);
         auto rightWrongHits = hitChecker.nHitsBeforeVtx(*right->extra(), theConversionVertex);
         nHitsBeforeVtx.push_back(leftWrongHits.first);
         nHitsBeforeVtx.push_back(rightWrongHits.first);
         dlClosestHitToVtx.push_back(leftWrongHits.second);
         dlClosestHitToVtx.push_back(rightWrongHits.second);
       }
 
       uint8_t nSharedHits = hitChecker.nSharedHits(*left.get(), *right.get());
 
       //if using kinematic fit, check with chi2 post cut
       if (theConversionVertex.isValid()) {
         const float chi2Prob = ChiSquaredProbability(theConversionVertex.chi2(), theConversionVertex.ndof());
         if (chi2Prob < vtxChi2_)
           highPurityPair = false;
       }
 
       //std::cout << "  highPurityPair after vertex cut " <<  highPurityPair << std::endl;
       std::vector<math::XYZPointF> trkPositionAtEcal;
       std::vector<reco::CaloClusterPtr> matchingBC;
 
       if (allowTrackBC_) {  //TODO find out the BC ptrs if not doing matching, otherwise, leave it empty
         //const int lbc_handle = bcHandleId[ll-allTracks.begin()],
         //        rbc_handle = bcHandleId[rr-allTracks.begin()];
 
         std::map<edm::Ptr<reco::ConversionTrack>, math::XYZPointF>::const_iterator trackImpactPositionLeft =
             trackImpactPosition.find(ll->second);
         std::map<edm::Ptr<reco::ConversionTrack>, math::XYZPointF>::const_iterator trackImpactPositionRight =
             trackImpactPosition.find(rr->second);
         std::map<edm::Ptr<reco::ConversionTrack>, reco::CaloClusterPtr>::const_iterator trackMatchedBCLeft =
             trackMatchedBC.find(ll->second);
         std::map<edm::Ptr<reco::ConversionTrack>, reco::CaloClusterPtr>::const_iterator trackMatchedBCRight =
             trackMatchedBC.find(rr->second);
 
         if (trackImpactPositionLeft != trackImpactPosition.end()) {
           trkPositionAtEcal.push_back(trackImpactPositionLeft->second);  //left track
         } else {
           trkPositionAtEcal.push_back(math::XYZPointF());  //left track
         }
         if (trackImpactPositionRight != trackImpactPosition.end()) {  //second track ECAL position may be invalid
           trkPositionAtEcal.push_back(trackImpactPositionRight->second);
         }
 
         double total_e_bc = 0.;
         if (trackMatchedBCLeft != trackMatchedBC.end()) {
           matchingBC.push_back(trackMatchedBCLeft->second);  //left track
           total_e_bc += trackMatchedBCLeft->second->energy();
         } else {
           matchingBC.push_back(reco::CaloClusterPtr());  //left track
         }
         if (trackMatchedBCRight != trackMatchedBC.end()) {  //second track ECAL position may be invalid
           matchingBC.push_back(trackMatchedBCRight->second);
           total_e_bc += trackMatchedBCRight->second->energy();
         }
 
         if (total_e_bc < energyTotalBC_) {
           highPurityPair = false;
         }
       }
       //signature cuts, then check if vertex, then post-selection cuts
       highPurityPair = highPurityPair && track1HighPurity && track2HighPurity && goodVertex &&
                        checkPhi(left, right, trackerGeom, magField, theConversionVertex);
 
       /*
         for ( std::vector<edm::RefToBase<reco::Track> >::iterator iTk=trackPairRef.begin();  iTk!=trackPairRef.end(); iTk++) {
         math::XYZPointF impPos;
         if ( getTrackImpactPosition(*iTk, trackerGeom, magField, impPos) ) {
            
         }
 
         }
       */
 
       const float minAppDist = approachDist;
       reco::Conversion::ConversionAlgorithm algo = reco::Conversion::algoByName(algoName_);
       float dummy = 0;
       reco::CaloClusterPtrVector scPtrVec;
       reco::Conversion newCandidate(scPtrVec,
                                     trackPairRef,
                                     trkPositionAtEcal,
                                     theConversionVertex,
                                     matchingBC,
                                     minAppDist,
                                     trackInnPos,
                                     trackPin,
                                     trackPout,
                                     nHitsBeforeVtx,
                                     dlClosestHitToVtx,
                                     nSharedHits,
                                     dummy,
                                     algo);
       // Fill in scPtrVec with the macthing SC
       if (matchingSC(superClusterPtrs, newCandidate, scPtrVec))
         newCandidate.setMatchingSuperCluster(scPtrVec);
 
       newCandidate.setQuality(reco::Conversion::highPurity, highPurityPair);
       bool generalTracksOnly = ll->second->isTrackerOnly() && rr->second->isTrackerOnly() &&
                                !dynamic_cast<const reco::GsfTrack*>(ll->second->trackRef().get()) &&
                                !dynamic_cast<const reco::GsfTrack*>(rr->second->trackRef().get());
       bool gsfTracksOpenOnly = ll->second->isGsfTrackOpen() && rr->second->isGsfTrackOpen();
       bool arbitratedEcalSeeded = ll->second->isArbitratedEcalSeeded() && rr->second->isArbitratedEcalSeeded();
       bool arbitratedMerged = ll->second->isArbitratedMerged() && rr->second->isArbitratedMerged();
       bool arbitratedMergedEcalGeneral =
           ll->second->isArbitratedMergedEcalGeneral() && rr->second->isArbitratedMergedEcalGeneral();
 
       newCandidate.setQuality(reco::Conversion::generalTracksOnly, generalTracksOnly);
       newCandidate.setQuality(reco::Conversion::gsfTracksOpenOnly, gsfTracksOpenOnly);
       newCandidate.setQuality(reco::Conversion::arbitratedEcalSeeded, arbitratedEcalSeeded);
       newCandidate.setQuality(reco::Conversion::arbitratedMerged, arbitratedMerged);
       newCandidate.setQuality(reco::Conversion::arbitratedMergedEcalGeneral, arbitratedMergedEcalGeneral);
 
       outputConvPhotonCollection.push_back(newCandidate);
     }
   }
 }

◆ buildSuperAndBasicClusterGeoMap()

void ConversionProducer::buildSuperAndBasicClusterGeoMap	(	const edm::Event &	iEvent,
		std::multimap< double, reco::CaloClusterPtr > &	basicClusterPtrs,
		std::multimap< double, reco::CaloClusterPtr > &	superClusterPtrs
	)

private

Definition at line 355 of file ConversionProducer.cc.

References bcBarrelCollection_, bcEndcapCollection_, energyBC_, patZpeak::handle, iEvent, edm::HandleBase::isValid(), minSCEt_, scBarrelProducer_, and scEndcapProducer_.

Referenced by produce().

                                                                                                                     {
   // Get the Super Cluster collection in the Barrel
   edm::Handle<edm::View<reco::CaloCluster> > scBarrelHandle;
   iEvent.getByToken(scBarrelProducer_, scBarrelHandle);
   if (!scBarrelHandle.isValid()) {
     edm::LogError("ConvertedPhotonProducer") << "Error! Can't get the barrel superclusters!";
   }
 
   // Get the Super Cluster collection in the Endcap
   edm::Handle<edm::View<reco::CaloCluster> > scEndcapHandle;
   iEvent.getByToken(scEndcapProducer_, scEndcapHandle);
   if (!scEndcapHandle.isValid()) {
     edm::LogError("ConvertedPhotonProducer") << "Error! Can't get the endcap superclusters!";
   }
 
   edm::Handle<edm::View<reco::CaloCluster> > bcBarrelHandle;
   edm::Handle<edm::View<reco::CaloCluster> > bcEndcapHandle;  //TODO check cluster type if BasicCluster or PFCluster
 
   iEvent.getByToken(bcBarrelCollection_, bcBarrelHandle);
   if (!bcBarrelHandle.isValid()) {
     edm::LogError("ConvertedPhotonProducer") << "Error! Can't get the barrel basic clusters!";
   }
 
   iEvent.getByToken(bcEndcapCollection_, bcEndcapHandle);
   if (!bcEndcapHandle.isValid()) {
     edm::LogError("ConvertedPhotonProducer") << "Error! Can't get the endcap basic clusters!";
   }
 
   if (bcBarrelHandle.isValid()) {
     for (auto const& handle : {bcBarrelHandle, bcEndcapHandle}) {
       for (auto const& bc : handle->ptrs()) {
         if (bc->energy() > energyBC_)
           basicClusterPtrs.emplace(bc->position().eta(), bc);
       }
     }
   }
 
   if (scBarrelHandle.isValid()) {
     for (auto const& handle : {scBarrelHandle, scEndcapHandle}) {
       for (auto const& sc : handle->ptrs()) {
         if (sc->energy() > minSCEt_)
           superClusterPtrs.emplace(sc->position().eta(), sc);
       }
     }
   }
 }

◆ checkPhi()

bool ConversionProducer::checkPhi	(	const edm::RefToBase< reco::Track > &	tk_l,
		const edm::RefToBase< reco::Track > &	tk_r,
		TrackerGeometry const &	trackerGeom,
		MagneticField const &	magField,
		const reco::Vertex &	the_vertex
	)

private

Definition at line 820 of file ConversionProducer.cc.

References allowDeltaPhi_, anyDirection, reco::deltaPhi(), deltaPhi_, HLT_2022v11_cff::dPhi, reco::Track::extra(), TrajectoryStateOnSurface::globalDirection(), reco::Track::innerMomentum(), trajectoryStateTransform::innerStateOnSurface(), edm::Ref< C, T, F >::isNonnull(), TrajectoryStateOnSurface::isValid(), PV3DBase< T, PVType, FrameType >::phi(), PropagatorWithMaterial::propagate(), makeMuonMisalignmentScenario::rot, and extraflags_cff::vtx.

Referenced by buildCollection().

                                                          {
   if (!allowDeltaPhi_)
     return true;
   //if track has innermost momentum, check with innermost phi
   //if track also has valid vertex, propagate to vertex then calculate phi there
   //if track has no innermost momentum, just return true, because track->phi() makes no sense
   if (tk_l->extra().isNonnull() && tk_r->extra().isNonnull()) {
     double iphi1 = tk_l->innerMomentum().phi(), iphi2 = tk_r->innerMomentum().phi();
     if (vtx.isValid()) {
       PropagatorWithMaterial propag(anyDirection, 0.000511, &magField);
 
       double recoPhoR = vtx.position().Rho();
       Surface::RotationType rot;
       ReferenceCountingPointer<BoundCylinder> theBarrel_(new BoundCylinder(
           recoPhoR,
           Surface::PositionType(0, 0, 0),
           rot,
           new SimpleCylinderBounds(
               recoPhoR - 0.001, recoPhoR + 0.001, -fabs(vtx.position().z()), fabs(vtx.position().z()))));
       ReferenceCountingPointer<BoundDisk> theDisk_(new BoundDisk(
           Surface::PositionType(0, 0, vtx.position().z()), rot, new SimpleDiskBounds(0, recoPhoR, -0.001, 0.001)));
 
       const auto myTSOS1 = trajectoryStateTransform::innerStateOnSurface(*tk_l, trackerGeom, &magField);
       const auto myTSOS2 = trajectoryStateTransform::innerStateOnSurface(*tk_r, trackerGeom, &magField);
       TrajectoryStateOnSurface stateAtVtx1, stateAtVtx2;
       stateAtVtx1 = propag.propagate(myTSOS1, *theBarrel_);
       if (!stateAtVtx1.isValid()) {
         stateAtVtx1 = propag.propagate(myTSOS1, *theDisk_);
       }
       if (stateAtVtx1.isValid()) {
         iphi1 = stateAtVtx1.globalDirection().phi();
       }
       stateAtVtx2 = propag.propagate(myTSOS2, *theBarrel_);
       if (!stateAtVtx2.isValid()) {
         stateAtVtx2 = propag.propagate(myTSOS2, *theDisk_);
       }
       if (stateAtVtx2.isValid()) {
         iphi2 = stateAtVtx2.globalDirection().phi();
       }
     }
     const double dPhi = reco::deltaPhi(iphi1, iphi2);
     return (fabs(dPhi) < deltaPhi_);
   } else {
     return true;
   }
 }

◆ checkTrackPair()

bool ConversionProducer::checkTrackPair	(	const std::pair< edm::RefToBase< reco::Track >, reco::CaloClusterPtr > &	ll,
		const std::pair< edm::RefToBase< reco::Track >, reco::CaloClusterPtr > &	rr
	)

private

Definition at line 926 of file ConversionProducer.cc.

References allowTrackBC_, energyTotalBC_, edm::Ptr< T >::isNonnull(), rightBC_, and findQualityFiles::rr.

                                                                                                         {
   const reco::CaloClusterPtr& bc_l = ll.second;  //can be null, so check isNonnull()
   const reco::CaloClusterPtr& bc_r = rr.second;
 
   //The cuts should be ordered by considering if takes time and if cuts off many fakes
   if (allowTrackBC_) {
     //check energy of BC
     double total_e_bc = 0;
     if (bc_l.isNonnull())
       total_e_bc += bc_l->energy();
     if (rightBC_)
       if (bc_r.isNonnull())
         total_e_bc += bc_r->energy();
 
     if (total_e_bc < energyTotalBC_)
       return false;
   }
 
   return true;
 }

◆ checkVertex()

bool ConversionProducer::checkVertex	(	const reco::TransientTrack &	ttk_l,
		const reco::TransientTrack &	ttk_r,
		MagneticField const &	magField,
		reco::Vertex &	the_vertex
	)

inlineprivate

Definition at line 161 of file ConversionProducer.cc.

References ConversionVertexFinder::run(), and vertexFinder_.

Referenced by buildCollection().

                                                   {
     return vertexFinder_.run({ttk_l, ttk_r}, the_vertex);
   }

◆ etaTransformation()

double ConversionProducer::etaTransformation	(	float	EtaParticle,
		float	Zvertex
	)

private

Definition at line 948 of file ConversionProducer.cc.

References ETA, etaBarrelEndcap, dqm-mbProfile::log, PI, R_ECAL, funct::tan(), Z_Endcap, and ZEcal.

Referenced by matchingSC().

                                                                              {
   //---Definitions
   const float PI = 3.1415927;
 
   //---Definitions for ECAL
   const float R_ECAL = 136.5;
   const float Z_Endcap = 328.0;
   const float etaBarrelEndcap = 1.479;
 
   //---ETA correction
 
   float Theta = 0.0;
   float ZEcal = R_ECAL * sinh(EtaParticle) + Zvertex;
 
   if (ZEcal != 0.0)
     Theta = atan(R_ECAL / ZEcal);
   if (Theta < 0.0)
     Theta = Theta + PI;
   double ETA = -log(tan(0.5 * Theta));
 
   if (fabs(ETA) > etaBarrelEndcap) {
     float Zend = Z_Endcap;
     if (EtaParticle < 0.0)
       Zend = -Zend;
     float Zlen = Zend - Zvertex;
     float RR = Zlen / sinh(EtaParticle);
     Theta = atan(RR / Zend);
     if (Theta < 0.0)
       Theta = Theta + PI;
     ETA = -log(tan(0.5 * Theta));
   }
   //---Return the result
   return ETA;
   //---end
 }

◆ getMatchedBC()

bool ConversionProducer::getMatchedBC	(	const std::multimap< double, reco::CaloClusterPtr > &	bcMap,
		const math::XYZPointF &	trackImpactPosition,
		reco::CaloClusterPtr &	closestBC
	)

private

Definition at line 788 of file ConversionProducer.cc.

References HLT_2022v11_cff::delta_eta, HLT_2022v11_cff::delta_phi, reco::deltaPhi(), dEtaTkBC_, dPhiTkBC_, halfWayEta_, and HLT_2022v11_cff::min_eta.

Referenced by buildCollection().

                                                                      {
   const double track_eta = trackImpactPosition.eta();
   const double track_phi = trackImpactPosition.phi();
 
   double min_eta = 999., min_phi = 999.;
   reco::CaloClusterPtr closest_bc;
   for (std::multimap<double, reco::CaloClusterPtr>::const_iterator bc = bcMap.lower_bound(track_eta - halfWayEta_);
        bc != bcMap.upper_bound(track_eta + halfWayEta_);
        ++bc) {  //use eta map to select possible BC collection then loop in
     const reco::CaloClusterPtr& ebc = bc->second;
     const double delta_eta = track_eta - (ebc->position().eta());
     const double delta_phi = reco::deltaPhi(track_phi, (ebc->position().phi()));
     if (fabs(delta_eta) < dEtaTkBC_ && fabs(delta_phi) < dPhiTkBC_) {
       if (fabs(min_eta) > fabs(delta_eta) && fabs(min_phi) > fabs(delta_phi)) {  //take the closest to track BC
         min_eta = delta_eta;
         min_phi = delta_phi;
         closest_bc = bc->second;
         //TODO check if min_eta>delta_eta but min_phi<delta_phi
       }
     }
   }
 
   if (min_eta < 999.) {
     closestBC = closest_bc;
     return true;
   } else
     return false;
 }

◆ getTrackImpactPosition()

bool ConversionProducer::getTrackImpactPosition	(	const reco::Track *	tk_ref,
		TrackerGeometry const &	trackerGeom,
		MagneticField const &	magField,
		math::XYZPointF &	ew
	)

private

Definition at line 716 of file ConversionProducer.cc.

References alongMomentum, barrelHalfLength, barrelRadius, endcapRadius, endcapZ, geometryDiff::epsilon, PV3DBase< T, PVType, FrameType >::eta(), f, TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), trajectoryStateTransform::outerStateOnSurface(), PropagatorWithMaterial::propagate(), and makeMuonMisalignmentScenario::rot.

Referenced by buildCollection().

                                                                    {
   PropagatorWithMaterial propag(alongMomentum, 0.000511, &magField);
 
   ReferenceCountingPointer<Surface> ecalWall(new BoundCylinder(
       129.f, GlobalPoint(0., 0., 0.), TkRotation<float>(), new SimpleCylinderBounds(129, 129, -320.5, 320.5)));
   constexpr float epsilon = 0.001;
   Surface::RotationType rot;  // unit rotation matrix
   constexpr float barrelRadius = 129.f;
   constexpr float barrelHalfLength = 270.9f;
   constexpr float endcapRadius = 171.1f;
   constexpr float endcapZ = 320.5f;
   ReferenceCountingPointer<BoundCylinder> theBarrel_(new BoundCylinder(
       barrelRadius,
       Surface::PositionType(0, 0, 0),
       rot,
       new SimpleCylinderBounds(barrelRadius - epsilon, barrelRadius + epsilon, -barrelHalfLength, barrelHalfLength)));
   ReferenceCountingPointer<BoundDisk> theNegativeEtaEndcap_(new BoundDisk(
       Surface::PositionType(0, 0, -endcapZ), rot, new SimpleDiskBounds(0, endcapRadius, -epsilon, epsilon)));
   ReferenceCountingPointer<BoundDisk> thePositiveEtaEndcap_(new BoundDisk(
       Surface::PositionType(0, 0, endcapZ), rot, new SimpleDiskBounds(0, endcapRadius, -epsilon, epsilon)));
 
   //const TrajectoryStateOnSurface myTSOS = trajectoryStateTransform::innerStateOnSurface(*(*ref), *trackerGeom, magField);
   const auto myTSOS = trajectoryStateTransform::outerStateOnSurface(*tk_ref, trackerGeom, &magField);
   TrajectoryStateOnSurface stateAtECAL;
   stateAtECAL = propag.propagate(myTSOS, *theBarrel_);
   if (!stateAtECAL.isValid() || (stateAtECAL.isValid() && fabs(stateAtECAL.globalPosition().eta()) > 1.479f)) {
     //endcap propagator
     if (myTSOS.globalPosition().z() > 0.) {
       stateAtECAL = propag.propagate(myTSOS, *thePositiveEtaEndcap_);
     } else {
       stateAtECAL = propag.propagate(myTSOS, *theNegativeEtaEndcap_);
     }
   }
   if (stateAtECAL.isValid()) {
     ew = stateAtECAL.globalPosition();
     return true;
   } else
     return false;
 }

◆ matchingSC()

bool ConversionProducer::matchingSC	(	const std::multimap< double, reco::CaloClusterPtr > &	scMap,
		reco::Conversion &	conv,
		reco::CaloClusterPtrVector &	mSC
	)

private

Definition at line 759 of file ConversionProducer.cc.

References HLT_2022v11_cff::delta_eta, HLT_2022v11_cff::delta_phi, reco::deltaPhi(), dEtacutForSCmatching_, dPhicutForSCmatching_, TrackSplittingMonitor_cfi::dphiMin, etaTransformation(), match(), edm::PtrVector< T >::push_back(), reco::Conversion::refittedPairMomentum(), and reco::Conversion::zOfPrimaryVertexFromTracks().

Referenced by buildCollection().

                                                                    {
   //  double dRMin=999.;
   double detaMin = 999.;
   double dphiMin = 999.;
   reco::CaloClusterPtr match;
   for (std::multimap<double, reco::CaloClusterPtr>::const_iterator scItr = scMap.begin(); scItr != scMap.end();
        scItr++) {
     const reco::CaloClusterPtr& sc = scItr->second;
     const double delta_phi = reco::deltaPhi(aConv.refittedPairMomentum().phi(), sc->phi());
     double sceta = sc->eta();
     double conveta = etaTransformation(aConv.refittedPairMomentum().eta(), aConv.zOfPrimaryVertexFromTracks());
     const double delta_eta = fabs(conveta - sceta);
     if (fabs(delta_eta) < fabs(detaMin) && fabs(delta_phi) < fabs(dphiMin)) {
       detaMin = fabs(delta_eta);
       dphiMin = fabs(delta_phi);
       match = sc;
     }
   }
 
   if (fabs(detaMin) < dEtacutForSCmatching_ && fabs(dphiMin) < dPhicutForSCmatching_) {
     mSC.push_back(match);
     return true;
   } else
     return false;
 }

◆ preselectTrackPair()

bool ConversionProducer::preselectTrackPair	(	const reco::TransientTrack &	ttk_l,
		const reco::TransientTrack &	ttk_r,
		double &	appDist
	)

private

Definition at line 871 of file ConversionProducer.cc.

References funct::abs(), allowDeltaCot_, allowMinApproach_, TangentApproachInRPhi::calculate(), ClosestApproachInRPhi::calculate(), TangentApproachInRPhi::crossingPoint(), ClosestApproachInRPhi::crossingPoint(), deltaCotTheta_, dzCut_, reco::Track::innerMomentum(), reco::TransientTrack::innermostMeasurementState(), maxTrackRho_, maxTrackZ_, minApproachHigh_, PV3DBase< T, PVType, FrameType >::perp(), TangentApproachInRPhi::perpdist(), r_cut, rho, TangentApproachInRPhi::status(), ClosestApproachInRPhi::status(), funct::tan(), reco::TransientTrack::track(), TangentApproachInRPhi::trajectoryParameters(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by buildCollection().

                                                              {
   double dCotTheta = 1. / tan(ttk_l.track().innerMomentum().theta()) - 1. / tan(ttk_r.track().innerMomentum().theta());
   if (allowDeltaCot_ && (std::abs(dCotTheta) > deltaCotTheta_)) {
     return false;
   }
 
   //non-conversion hypothesis, reject prompt track pairs
   ClosestApproachInRPhi closest;
   closest.calculate(ttk_l.innermostMeasurementState(), ttk_r.innermostMeasurementState());
   if (!closest.status()) {
     return false;
   }
 
   if (closest.crossingPoint().perp() < r_cut) {
     return false;
   }
 
   //compute tangent point btw tracks (conversion hypothesis)
   TangentApproachInRPhi tangent;
   tangent.calculate(ttk_l.innermostMeasurementState(), ttk_r.innermostMeasurementState());
   if (!tangent.status()) {
     return false;
   }
 
   GlobalPoint tangentPoint = tangent.crossingPoint();
   double rho = tangentPoint.perp();
 
   //reject candidates well outside of tracker bounds
   if (rho > maxTrackRho_) {
     return false;
   }
 
   if (std::abs(tangentPoint.z()) > maxTrackZ_) {
     return false;
   }
 
   std::pair<GlobalTrajectoryParameters, GlobalTrajectoryParameters> trajs = tangent.trajectoryParameters();
 
   //very large separation in z, no hope
   if (std::abs(trajs.first.position().z() - trajs.second.position().z()) > dzCut_) {
     return false;
   }
 
   float minApproach = tangent.perpdist();
   appDist = minApproach;
 
   if (allowMinApproach_ && (minApproach < minApproachLow_ || minApproach > minApproachHigh_)) {
     return false;
   }
 
   return true;
 }

◆ produce()

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

overrideprivate

Definition at line 295 of file ConversionProducer.cc.

References buildCollection(), buildSuperAndBasicClusterGeoMap(), ConvertedPhotonCollection_, edm::EventSetup::getData(), iEvent, edm::HandleBase::isValid(), maxNumOfTrackInPU_, eostools::move(), edm::Handle< T >::product(), src_, submitPVValidationJobs::t, thettbuilder_, transientTrackBuilder_, usePvtx_, spclusmultinvestigator_cfi::vertexCollection, and vertexProducer_.

                                                                               {
   using namespace edm;
 
   reco::ConversionCollection outputConvPhotonCollection;
   auto outputConvPhotonCollection_p = std::make_unique<reco::ConversionCollection>();
 
   //std::cout << " ConversionProducer::produce " << std::endl;
   //Read multiple track input collections
 
   edm::Handle<edm::View<reco::ConversionTrack> > trackCollectionHandle;
   iEvent.getByToken(src_, trackCollectionHandle);
 
   //build map of ConversionTracks ordered in eta
   std::multimap<float, edm::Ptr<reco::ConversionTrack> > convTrackMap;
   for (auto const& t : trackCollectionHandle->ptrs())
     convTrackMap.emplace(t->track()->eta(), t);
 
   edm::Handle<reco::VertexCollection> vertexHandle;
   reco::VertexCollection vertexCollection;
   if (usePvtx_) {
     iEvent.getByToken(vertexProducer_, vertexHandle);
     if (!vertexHandle.isValid()) {
       edm::LogError("ConversionProducer") << "Error! Can't get the product primary Vertex Collection "
                                           << "\n";
       usePvtx_ = false;
     }
     if (usePvtx_)
       vertexCollection = *(vertexHandle.product());
   }
 
   thettbuilder_ = &iSetup.getData(transientTrackBuilder_);
 
   reco::Vertex the_pvtx;
   //because the priamry vertex is sorted by quality, the first one is the best
   if (!vertexCollection.empty())
     the_pvtx = *(vertexCollection.begin());
 
   if (trackCollectionHandle->size() > maxNumOfTrackInPU_) {
     iEvent.put(std::move(outputConvPhotonCollection_p), ConvertedPhotonCollection_);
     return;
   }
 
   // build Super and Basic cluster geometry map to search in eta bounds for clusters
   std::multimap<double, reco::CaloClusterPtr> basicClusterPtrs;
   std::multimap<double, reco::CaloClusterPtr> superClusterPtrs;
 
   buildSuperAndBasicClusterGeoMap(iEvent, basicClusterPtrs, superClusterPtrs);
 
   buildCollection(iEvent,
                   iSetup,
                   convTrackMap,
                   superClusterPtrs,
                   basicClusterPtrs,
                   the_pvtx,
                   outputConvPhotonCollection);  //allow empty basicClusterPtrs
 
   outputConvPhotonCollection_p->assign(outputConvPhotonCollection.begin(), outputConvPhotonCollection.end());
   iEvent.put(std::move(outputConvPhotonCollection_p), ConvertedPhotonCollection_);
 }

◆ toFConverterP()

math::XYZPointF ConversionProducer::toFConverterP ( const math::XYZPoint & val )

inlineprivate

Definition at line 186 of file ConversionProducer.cc.

References heppy_batch::val.

Referenced by buildCollection().

186 { return math::XYZPointF(val.x(), val.y(), val.z()); }

math::XYZPointF

ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< float > > XYZPointF

point in space with cartesian internal representation

Definition: Point3D.h:10

heppy_batch.val

val

Definition: heppy_batch.py:351

◆ toFConverterV()

math::XYZVectorF ConversionProducer::toFConverterV ( const math::XYZVector & val )

inlineprivate

Definition at line 188 of file ConversionProducer.cc.

References heppy_batch::val.

Referenced by buildCollection().

188 { return math::XYZVectorF(val.x(), val.y(), val.z()); }

math::XYZVectorF

ROOT::Math::DisplacementVector3D< ROOT::Math::Cartesian3D< float > > XYZVectorF

spatial vector with cartesian internal representation

Definition: Vector3D.h:16

heppy_batch.val

val

Definition: heppy_batch.py:351

◆ trackD0Cut() [1/2]

bool ConversionProducer::trackD0Cut ( const edm::RefToBase< reco::Track > & ref )

inlineprivate

Definition at line 706 of file ConversionProducer.cc.

References allowD0_, reco::TrackBase::charge(), reco::TrackBase::d0(), d0Cut_, and reco::TrackBase::d0Error().

Referenced by buildCollection().

                                                                              {
   //NOTE if not allow d0 cut, always true
   return ((!allowD0_) || !(ref->d0() * ref->charge() / ref->d0Error() < d0Cut_));
 }

◆ trackD0Cut() [2/2]

bool ConversionProducer::trackD0Cut	(	const edm::RefToBase< reco::Track > &	ref,
		const reco::Vertex &	the_pvtx
	)

inlineprivate

Definition at line 711 of file ConversionProducer.cc.

References allowD0_, reco::TrackBase::charge(), d0Cut_, reco::TrackBase::dxy(), reco::TrackBase::dxyError(), and reco::Vertex::position().

                                                                                                          {
   //
   return ((!allowD0_) || !(-ref->dxy(the_pvtx.position()) * ref->charge() / ref->dxyError() < d0Cut_));
 }

◆ trackQualityFilter()

bool ConversionProducer::trackQualityFilter	(	const edm::RefToBase< reco::Track > &	ref,
		bool	isLeft
	)

inlineprivate

Definition at line 695 of file ConversionProducer.cc.

References reco::Track::found(), maxChi2Left_, maxChi2Right_, minHitsLeft_, minHitsRight_, and reco::TrackBase::normalizedChi2().

Referenced by buildCollection().

                                                                                                   {
   bool pass = true;
   if (isLeft) {
     pass = (ref->normalizedChi2() < maxChi2Left_ && ref->found() >= minHitsLeft_);
   } else {
     pass = (ref->normalizedChi2() < maxChi2Right_ && ref->found() >= minHitsRight_);
   }
 
   return pass;
 }

Member Data Documentation

◆ algoName_

std::string ConversionProducer::algoName_

private

Definition at line 77 of file ConversionProducer.cc.

Referenced by buildCollection().

◆ allowD0_

bool ConversionProducer::allowD0_

private

Definition at line 94 of file ConversionProducer.cc.

Referenced by trackD0Cut().

◆ allowDeltaCot_

bool ConversionProducer::allowDeltaCot_

private

Definition at line 94 of file ConversionProducer.cc.

Referenced by preselectTrackPair().

◆ allowDeltaPhi_

bool ConversionProducer::allowDeltaPhi_

private

Definition at line 94 of file ConversionProducer.cc.

Referenced by checkPhi().

◆ allowMinApproach_

bool ConversionProducer::allowMinApproach_

private

Definition at line 94 of file ConversionProducer.cc.

Referenced by preselectTrackPair().

◆ allowOppCharge_

bool ConversionProducer::allowOppCharge_

private

Definition at line 94 of file ConversionProducer.cc.

Referenced by buildCollection().

◆ allowSingleLeg_

bool ConversionProducer::allowSingleLeg_

private

Definition at line 128 of file ConversionProducer.cc.

◆ allowTrackBC_

bool ConversionProducer::allowTrackBC_

private

Definition at line 94 of file ConversionProducer.cc.

Referenced by buildCollection(), and checkTrackPair().

◆ allowVertex_

bool ConversionProducer::allowVertex_

private

Definition at line 94 of file ConversionProducer.cc.

◆ bcBarrelCollection_

edm::EDGetTokenT<edm::View<reco::CaloCluster> > ConversionProducer::bcBarrelCollection_

private

Definition at line 86 of file ConversionProducer.cc.

Referenced by buildSuperAndBasicClusterGeoMap().

◆ bcEndcapCollection_

edm::EDGetTokenT<edm::View<reco::CaloCluster> > ConversionProducer::bcEndcapCollection_

private

Definition at line 87 of file ConversionProducer.cc.

Referenced by buildSuperAndBasicClusterGeoMap().

◆ bypassPreselEcal_

bool ConversionProducer::bypassPreselEcal_

private

Definition at line 96 of file ConversionProducer.cc.

Referenced by buildCollection().

◆ bypassPreselEcalEcal_

bool ConversionProducer::bypassPreselEcalEcal_

private

Definition at line 96 of file ConversionProducer.cc.

Referenced by buildCollection().

◆ bypassPreselGsf_

bool ConversionProducer::bypassPreselGsf_

private

Definition at line 96 of file ConversionProducer.cc.

Referenced by buildCollection().

◆ ConvertedPhotonCollection_

std::string ConversionProducer::ConvertedPhotonCollection_

private

Definition at line 88 of file ConversionProducer.cc.

Referenced by produce().

◆ d0Cut_

double ConversionProducer::d0Cut_

private

Definition at line 115 of file ConversionProducer.cc.

Referenced by trackD0Cut().

◆ deltaCotTheta_

double ConversionProducer::deltaCotTheta_

private

Definition at line 122 of file ConversionProducer.cc.

Referenced by preselectTrackPair().

◆ deltaEta_

double ConversionProducer::deltaEta_

private

Definition at line 104 of file ConversionProducer.cc.

Referenced by buildCollection().

◆ deltaPhi_

double ConversionProducer::deltaPhi_

private

Definition at line 122 of file ConversionProducer.cc.

Referenced by checkPhi().

◆ dEtacutForSCmatching_

double ConversionProducer::dEtacutForSCmatching_

private

Definition at line 111 of file ConversionProducer.cc.

Referenced by matchingSC().

◆ dEtaTkBC_

double ConversionProducer::dEtaTkBC_

private

Definition at line 117 of file ConversionProducer.cc.

Referenced by getMatchedBC().

◆ dPhicutForSCmatching_

double ConversionProducer::dPhicutForSCmatching_

private

Definition at line 112 of file ConversionProducer.cc.

Referenced by matchingSC().

◆ dPhiTkBC_

double ConversionProducer::dPhiTkBC_

private

Definition at line 117 of file ConversionProducer.cc.

Referenced by getMatchedBC().

◆ dzCut_

double ConversionProducer::dzCut_

private

Definition at line 116 of file ConversionProducer.cc.

Referenced by preselectTrackPair().

◆ energyBC_

double ConversionProducer::energyBC_

private

Definition at line 113 of file ConversionProducer.cc.

Referenced by buildSuperAndBasicClusterGeoMap().

◆ energyTotalBC_

double ConversionProducer::energyTotalBC_

private

Definition at line 114 of file ConversionProducer.cc.

Referenced by buildCollection(), and checkTrackPair().

◆ halfWayEta_

double ConversionProducer::halfWayEta_

private

Definition at line 106 of file ConversionProducer.cc.

Referenced by getMatchedBC().

◆ halfWayPhi_

double ConversionProducer::halfWayPhi_

private

Definition at line 106 of file ConversionProducer.cc.

◆ magneticField_

edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> ConversionProducer::magneticField_

private

Definition at line 92 of file ConversionProducer.cc.

Referenced by buildCollection().

◆ maxChi2Left_

double ConversionProducer::maxChi2Left_

private

Definition at line 119 of file ConversionProducer.cc.

Referenced by trackQualityFilter().

◆ maxChi2Right_

double ConversionProducer::maxChi2Right_

private

Definition at line 119 of file ConversionProducer.cc.

Referenced by trackQualityFilter().

◆ maxNumOfTrackInPU_

unsigned int ConversionProducer::maxNumOfTrackInPU_

private

Definition at line 107 of file ConversionProducer.cc.

Referenced by produce().

◆ maxTrackRho_

double ConversionProducer::maxTrackRho_

private

Definition at line 109 of file ConversionProducer.cc.

Referenced by preselectTrackPair().

◆ maxTrackZ_

double ConversionProducer::maxTrackZ_

private

Definition at line 108 of file ConversionProducer.cc.

Referenced by preselectTrackPair().

◆ minApproachHigh_

double ConversionProducer::minApproachHigh_

private

Definition at line 122 of file ConversionProducer.cc.

Referenced by preselectTrackPair().

◆ minApproachLow_

double ConversionProducer::minApproachLow_

private

Definition at line 122 of file ConversionProducer.cc.

◆ minHitsLeft_

double ConversionProducer::minHitsLeft_

private

Definition at line 120 of file ConversionProducer.cc.

Referenced by trackQualityFilter().

◆ minHitsRight_

double ConversionProducer::minHitsRight_

private

Definition at line 120 of file ConversionProducer.cc.

Referenced by trackQualityFilter().

◆ minSCEt_

double ConversionProducer::minSCEt_

private

Definition at line 110 of file ConversionProducer.cc.

Referenced by buildSuperAndBasicClusterGeoMap().

◆ r_cut

double ConversionProducer::r_cut

private

Definition at line 125 of file ConversionProducer.cc.

Referenced by preselectTrackPair().

◆ rightBC_

bool ConversionProducer::rightBC_

private

Definition at line 129 of file ConversionProducer.cc.

Referenced by checkTrackPair().

◆ scBarrelProducer_

edm::EDGetTokenT<edm::View<reco::CaloCluster> > ConversionProducer::scBarrelProducer_

private

Definition at line 84 of file ConversionProducer.cc.

Referenced by buildSuperAndBasicClusterGeoMap().

◆ scEndcapProducer_

edm::EDGetTokenT<edm::View<reco::CaloCluster> > ConversionProducer::scEndcapProducer_

private

Definition at line 85 of file ConversionProducer.cc.

Referenced by buildSuperAndBasicClusterGeoMap().

◆ src_

edm::EDGetTokenT<edm::View<reco::ConversionTrack> > ConversionProducer::src_

private

Definition at line 82 of file ConversionProducer.cc.

Referenced by produce().

◆ thettbuilder_

const TransientTrackBuilder* ConversionProducer::thettbuilder_

private

Definition at line 102 of file ConversionProducer.cc.

Referenced by buildCollection(), and produce().

◆ trackerGeometry_

edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> ConversionProducer::trackerGeometry_

private

Definition at line 91 of file ConversionProducer.cc.

Referenced by buildCollection().

◆ transientTrackBuilder_

edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> ConversionProducer::transientTrackBuilder_

private

Definition at line 90 of file ConversionProducer.cc.

Referenced by produce().

◆ usePvtx_

bool ConversionProducer::usePvtx_

private

Definition at line 98 of file ConversionProducer.cc.

Referenced by produce().

◆ vertexFinder_

ConversionVertexFinder ConversionProducer::vertexFinder_

private

Definition at line 100 of file ConversionProducer.cc.

Referenced by checkVertex().

◆ vertexProducer_

edm::EDGetTokenT<reco::VertexCollection> ConversionProducer::vertexProducer_

private

Definition at line 99 of file ConversionProducer.cc.

Referenced by produce().

◆ vtxChi2_

double ConversionProducer::vtxChi2_

private

Definition at line 126 of file ConversionProducer.cc.

Referenced by buildCollection().

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Point

◆ PointCollection

Constructor & Destructor Documentation

◆ ConversionProducer()

Member Function Documentation

◆ buildCollection()

◆ buildSuperAndBasicClusterGeoMap()

◆ checkPhi()

◆ checkTrackPair()

◆ checkVertex()

◆ etaTransformation()

◆ getMatchedBC()

◆ getTrackImpactPosition()

◆ matchingSC()

◆ preselectTrackPair()

◆ produce()

◆ toFConverterP()

◆ toFConverterV()

◆ trackD0Cut() [1/2]

◆ trackD0Cut() [2/2]

◆ trackQualityFilter()

Member Data Documentation

◆ algoName_

◆ allowD0_

◆ allowDeltaCot_

◆ allowDeltaPhi_

◆ allowMinApproach_

◆ allowOppCharge_

◆ allowSingleLeg_

◆ allowTrackBC_

◆ allowVertex_

◆ bcBarrelCollection_

◆ bcEndcapCollection_

◆ bypassPreselEcal_

◆ bypassPreselEcalEcal_

◆ bypassPreselGsf_

◆ ConvertedPhotonCollection_

◆ d0Cut_

◆ deltaCotTheta_

◆ deltaEta_

◆ deltaPhi_

◆ dEtacutForSCmatching_

◆ dEtaTkBC_

◆ dPhicutForSCmatching_

◆ dPhiTkBC_

◆ dzCut_

◆ energyBC_

◆ energyTotalBC_

◆ halfWayEta_

◆ halfWayPhi_

◆ magneticField_

◆ maxChi2Left_

◆ maxChi2Right_

◆ maxNumOfTrackInPU_

◆ maxTrackRho_

◆ maxTrackZ_

◆ minApproachHigh_

◆ minApproachLow_

◆ minHitsLeft_

◆ minHitsRight_

◆ minSCEt_

◆ r_cut

◆ rightBC_

◆ scBarrelProducer_

◆ scEndcapProducer_

◆ src_

◆ thettbuilder_

◆ trackerGeometry_

◆ transientTrackBuilder_

◆ usePvtx_

◆ vertexFinder_

◆ vertexProducer_

◆ vtxChi2_