ConversionProducer Class Reference

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.

References reco::TrackBase::algo(), reco::Conversion::algoByName(), algoName_, allowOppCharge_, allowTrackBC_, muonTagProbeFilters_cff::allTracks, reco::Conversion::arbitratedEcalSeeded, tkConvValidator_cfi::arbitratedEcalSeeded, reco::Conversion::arbitratedMerged, tkConvValidator_cfi::arbitratedMerged, reco::Conversion::arbitratedMergedEcalGeneral, TransientTrackBuilder::build(), bypassPreselEcal_, bypassPreselEcalEcal_, bypassPreselGsf_, edm::RefToBase< T >::castTo(), reco::TrackBase::charge(), checkPhi(), checkVertex(), reco::Vertex::chi2(), ChiSquaredProbability(), deltaEta_, energyTotalBC_, reco::Track::extra(), reco::Conversion::generalTracksOnly, tkConvValidator_cfi::generalTracksOnly, edm::RefToBase< T >::get(), edm::EventSetup::getData(), getMatchedBC(), getTrackImpactPosition(), reco::TrackBase::gsf, reco::Conversion::gsfTracksOpenOnly, reco::Conversion::highPurity, reco::Track::innerMomentum(), reco::Track::innerPosition(), reco::TrackBase::inOutEcalSeededConv, edm::Ref< C, T, F >::isNonnull(), reco::Vertex::isValid(), magneticField_, matchingSC(), reco::Vertex::ndof(), ConversionHitChecker::nHitsBeforeVtx(), ConversionHitChecker::nSharedHits(), reco::Track::outerMomentum(), reco::TrackBase::outInEcalSeededConv, preselectTrackPair(), findQualityFiles::rr, reco::Conversion::setMatchingSuperCluster(), reco::Conversion::setQuality(), thettbuilder_, toFConverterP(), toFConverterV(), trackD0Cut(), trackerGeometry_, trackQualityFilter(), and vtxChi2_.

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_2024v12_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 L1BJetProducer_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(), and Z_Endcap.

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_2024v12_cff::delta_eta, HLT_2024v12_cff::delta_phi, reco::deltaPhi(), dEtaTkBC_, dPhiTkBC_, halfWayEta_, HLT_2024v12_cff::min_eta, and leptonTimeLifeInfo_common_cff::track_phi.

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, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), 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_2024v12_cff::delta_eta, HLT_2024v12_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(), pv::closest(), TangentApproachInRPhi::crossingPoint(), deltaCotTheta_, dzCut_, reco::Track::innerMomentum(), reco::TransientTrack::innermostMeasurementState(), maxTrackRho_, maxTrackZ_, minApproachHigh_, PV3DBase< T, PVType, FrameType >::perp(), TangentApproachInRPhi::perpdist(), r_cut, rho, TangentApproachInRPhi::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().

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

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().

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

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().