#include <AreaSeededTrackingRegionsBuilder.h>

Public Member Functions
	Builder (const AreaSeededTrackingRegionsBuilder conf, const MagneticField field, const MultipleScatteringParametrisationMaker *msmaker)

std::unique_ptr< TrackingRegion >	region (const Origin &origin, const std::vector< Area > &areas) const

std::unique_ptr< TrackingRegion >	region (const Origin &origin, const edm::VecArray< Area, 2 > &areas) const

std::vector< std::unique_ptr< TrackingRegion > >	regions (const Origins &origins, const std::vector< Area > &areas) const

void	setCandidates (const TrackingSeedCandidates::Objects cands)

void	setMeasurementTracker (const MeasurementTrackerEvent *mte)

	~Builder ()=default

Private Member Functions
template<typename T >
std::unique_ptr< TrackingRegion >	regionImpl (const Origin &origin, const T &areas) const

Private Attributes
TrackingSeedCandidates::Objects	candidates

const AreaSeededTrackingRegionsBuilder *	m_conf = nullptr

const MagneticField *	m_field = nullptr

const MeasurementTrackerEvent *	m_measurementTracker = nullptr

const MultipleScatteringParametrisationMaker *	m_msmaker = nullptr

Detailed Description

Definition at line 79 of file AreaSeededTrackingRegionsBuilder.h.

Constructor & Destructor Documentation

◆ Builder()

AreaSeededTrackingRegionsBuilder::Builder::Builder	(	const AreaSeededTrackingRegionsBuilder *	conf,
		const MagneticField *	field,
		const MultipleScatteringParametrisationMaker *	msmaker
	)

inlineexplicit

Definition at line 81 of file AreaSeededTrackingRegionsBuilder.h.

84 : m_conf(conf), m_field(field), m_msmaker(msmaker) {}

AreaSeededTrackingRegionsBuilder::Builder::m_conf

const AreaSeededTrackingRegionsBuilder * m_conf

Definition: AreaSeededTrackingRegionsBuilder.h:98

AreaSeededTrackingRegionsBuilder::Builder::m_field

const MagneticField * m_field

Definition: AreaSeededTrackingRegionsBuilder.h:100

AreaSeededTrackingRegionsBuilder::Builder::m_msmaker

const MultipleScatteringParametrisationMaker * m_msmaker

Definition: AreaSeededTrackingRegionsBuilder.h:101

◆ ~Builder()

AreaSeededTrackingRegionsBuilder::Builder::~Builder ( )

default

Member Function Documentation

◆ region() [1/2]

std::unique_ptr< TrackingRegion > AreaSeededTrackingRegionsBuilder::Builder::region	(	const Origin &	origin,
		const std::vector< Area > &	areas
	)		const

Definition at line 89 of file AreaSeededTrackingRegionsBuilder.cc.

Referenced by regions().

                                                               {
   return regionImpl(origin, areas);
 }

◆ region() [2/2]

std::unique_ptr< TrackingRegion > AreaSeededTrackingRegionsBuilder::Builder::region	(	const Origin &	origin,
		const edm::VecArray< Area, 2 > &	areas
	)		const

Definition at line 93 of file AreaSeededTrackingRegionsBuilder.cc.

                                                                    {
   return regionImpl(origin, areas);
 }

◆ regionImpl()

template<typename T >

std::unique_ptr< TrackingRegion > AreaSeededTrackingRegionsBuilder::Builder::regionImpl	(	const Origin &	origin,
		const T &	areas
	)		const

private

Definition at line 99 of file AreaSeededTrackingRegionsBuilder.cc.

References funct::abs(), custom_jme_cff::area, HLT_2023v12_cff::candidates, funct::cos(), ztail::d, SiPixelRawToDigiRegional_cfi::deltaPhi, reco::deltaPhi(), HLT_2023v12_cff::dEta, HLT_2023v12_cff::dPhi, TrackingDataMCValidation_Standalone_cff::etamax, TrackingDataMCValidation_Standalone_cff::etamin, JetChargeProducer_cfi::exp, f, LogDebug, LogTrace, M_PI, SiStripPI::max, razorScouting_cff::maxEta, HLT_2023v12_cff::maxPhi, SiStripPI::min, EgHLTOffEleSelection_cfi::minEta, HLT_2023v12_cff::minPhi, normalizedPhi(), perp2(), phimax, phimin, alignCSCRings::r, Validation_hcalonly_cfi::sign, funct::sin(), mathSSE::sqrt(), funct::tan(), createJobs::tmp, x, y, and z.

                                                                                                             {
   float minEta = std::numeric_limits<float>::max(), maxEta = std::numeric_limits<float>::lowest();
   float minPhi = std::numeric_limits<float>::max(), maxPhi = std::numeric_limits<float>::lowest();
 
   const auto& orig = origin.first;
 
   LogDebug("AreaSeededTrackingRegionsProducer") << "Origin x,y,z " << orig.x() << "," << orig.y() << "," << orig.z();
 
   auto vecFromOrigPlusRadius = [&](const std::array<float, 2>& vec) {
     const auto invlen = 1.f / std::sqrt(perp2(vec));
     const auto tmp = (1.f - m_conf->m_originRadius * invlen);
     return std::array<float, 2>{{vec[0] * tmp, vec[1] * tmp}};
   };
   auto tangentVec = [&](const std::array<float, 2>& vec, int sign) {
     const auto d = std::sqrt(perp2(vec));
     const auto r = m_conf->m_originRadius;
     const auto tmp = r / std::sqrt(d * d - r * r);
     // sign+ for counterclockwise, sign- for clockwise
     const auto orthvec = sign > 0 ? std::array<float, 2>{{-vec[1] * tmp, vec[0] * tmp}}
                                   : std::array<float, 2>{{vec[1] * tmp, -vec[0] * tmp}};
     return std::array<float, 2>{{vec[0] - orthvec[0], vec[1] - orthvec[1]}};
   };
 
   for (const auto& area : areas) {
     // straight line assumption is conservative, accounding for
     // low-pT bending would only tighten the eta-phi window
     LogTrace("AreaSeededTrackingRegionsBuilder")
         << " area x,y points " << area.x_rmin_phimin() << "," << area.y_rmin_phimin() << " "  // go around
         << area.x_rmin_phimax() << "," << area.y_rmin_phimax() << " " << area.x_rmax_phimax() << ","
         << area.y_rmax_phimax() << " " << area.x_rmax_phimin() << "," << area.y_rmax_phimin() << " "
         << "z " << area.zmin() << "," << area.zmax();
 
     // some common variables
     const float x_rmin_phimin = area.x_rmin_phimin() - orig.x();
     const float x_rmin_phimax = area.x_rmin_phimax() - orig.x();
     const float y_rmin_phimin = area.y_rmin_phimin() - orig.y();
     const float y_rmin_phimax = area.y_rmin_phimax() - orig.y();
 
     const std::array<float, 2> p_rmin_phimin = {{x_rmin_phimin, y_rmin_phimin}};
     const std::array<float, 2> p_rmin_phimax = {{x_rmin_phimax, y_rmin_phimax}};
     const std::array<float, 2> p_rmax_phimin = {{area.x_rmax_phimin() - orig.x(), area.y_rmax_phimin() - orig.y()}};
     const std::array<float, 2> p_rmax_phimax = {{area.x_rmax_phimax() - orig.x(), area.y_rmax_phimax() - orig.y()}};
 
     // eta
     {
       // find which of the two rmin points is closer to the origin
       //
       // closest point for p_rmin, farthest point for p_rmax
       const std::array<float, 2> p_rmin = perp2(p_rmin_phimin) < perp2(p_rmin_phimax) ? p_rmin_phimin : p_rmin_phimax;
       const std::array<float, 2> p_rmax = perp2(p_rmax_phimin) > perp2(p_rmax_phimax) ? p_rmax_phimin : p_rmax_phimax;
 
       // then calculate the xy vector from the point closest to p_rmin on
       // the (origin,originRadius) circle to the p_rmin
       // this will maximize the eta window
       const auto p_min = vecFromOrigPlusRadius(p_rmin);
       const auto p_max = vecFromOrigPlusRadius(p_rmax);
 
       // then we calculate the maximal eta window
       const auto etamin = std::min(etaFromXYZ(p_min[0], p_min[1], area.zmin() - (orig.z() + origin.second)),
                                    etaFromXYZ(p_max[0], p_max[1], area.zmin() - (orig.z() + origin.second)));
       const auto etamax = std::max(etaFromXYZ(p_min[0], p_min[1], area.zmax() - (orig.z() - origin.second)),
                                    etaFromXYZ(p_max[0], p_max[1], area.zmax() - (orig.z() - origin.second)));
 
       LogTrace("AreaSeededTrackingRegionBuilder") << "  eta min,max " << etamin << "," << etamax;
 
       minEta = std::min(minEta, etamin);
       maxEta = std::max(maxEta, etamax);
     }
 
     // phi
     {
       // For phi we construct the tangent lines of (origin,
       // originRadius) that go though each of the 4 points (in xy
       // plane) of the area. Easiest is to make a vector orthogonal to
       // origin->point vector which has a length of
       //
       // length = r*d/std::sqrt(d*d-r*r)
       //
       // where r is the originRadius and d is the distance from origin
       // to the point (to derive draw the situation and start with
       // definitions of sin/cos of one of the angles of the
       // right-angled triangle.
 
       // But we start with a "reference phi" so that we can easily
       // decide which phi is the largest/smallest without having too
       // much of headache with the wrapping. The reference is in
       // principle defined by the averages of y&x phimin/phimax at
       // rmin, but the '0.5f*' factor is omitted here to reduce
       // computations.
       const auto phi_ref = std::atan2(y_rmin_phimin + y_rmin_phimax, x_rmin_phimin + x_rmin_phimax);
 
       // for maximum phi we need the orthogonal vector to the left
       const auto tan_rmin_phimax = tangentVec(p_rmin_phimax, +1);
       const auto tan_rmax_phimax = tangentVec(p_rmax_phimax, +1);
       const auto phi_rmin_phimax = std::atan2(tan_rmin_phimax[1], tan_rmin_phimax[0]);
       const auto phi_rmax_phimax = std::atan2(tan_rmax_phimax[1], tan_rmax_phimax[0]);
 
       auto phimax =
           std::abs(reco::deltaPhi(phi_rmin_phimax, phi_ref)) > std::abs(reco::deltaPhi(phi_rmax_phimax, phi_ref))
               ? phi_rmin_phimax
               : phi_rmax_phimax;
 
       LogTrace("AreaSeededTrackingRegionBuilder")
           << "   rmin_phimax vec " << p_rmin_phimax[0] << "," << p_rmin_phimax[1] << " tangent " << tan_rmin_phimax[0]
           << "," << tan_rmin_phimax[1] << " phi " << phi_rmin_phimax << "\n"
           << "   rmax_phimax vec " << p_rmax_phimax[0] << "," << p_rmax_phimax[1] << " tangent " << tan_rmax_phimax[0]
           << "," << tan_rmax_phimax[1] << " phi " << phi_rmax_phimax << "\n"
           << "   phimax " << phimax;
 
       // for minimum phi we need the orthogonal vector to the right
       const auto tan_rmin_phimin = tangentVec(p_rmin_phimin, -1);
       const auto tan_rmax_phimin = tangentVec(p_rmax_phimin, -1);
       const auto phi_rmin_phimin = std::atan2(tan_rmin_phimin[1], tan_rmin_phimin[0]);
       const auto phi_rmax_phimin = std::atan2(tan_rmax_phimin[1], tan_rmax_phimin[0]);
 
       auto phimin =
           std::abs(reco::deltaPhi(phi_rmin_phimin, phi_ref)) > std::abs(reco::deltaPhi(phi_rmax_phimin, phi_ref))
               ? phi_rmin_phimin
               : phi_rmax_phimin;
 
       LogTrace("AreaSeededTrackingRegionBuilder")
           << "   rmin_phimin vec " << p_rmin_phimin[0] << "," << p_rmin_phimin[1] << " tangent " << tan_rmin_phimin[0]
           << "," << tan_rmin_phimin[1] << " phi " << phi_rmin_phimin << "\n"
           << "   rmax_phimin vec " << p_rmax_phimin[0] << "," << p_rmax_phimin[1] << " tangent " << tan_rmax_phimin[0]
           << "," << tan_rmax_phimin[1] << " phi " << phi_rmax_phimin << "\n"
           << "   phimin " << phimin;
 
       // wrapped around, need to decide which one to wrap
       if (phimax < phimin) {
         if (phimax < 0)
           phimax += 2 * M_PI;
         else
           phimin -= 2 * M_PI;
       }
 
       LogTrace("AreaSeededTrackingRegionBuilder") << "  phi min,max " << phimin << "," << phimax;
 
       minPhi = std::min(minPhi, phimin);
       maxPhi = std::max(maxPhi, phimax);
     }
 
     LogTrace("AreaSeededTrackingRegionBuilder")
         << "  windows after this area  eta " << minEta << "," << maxEta << " phi " << minPhi << "," << maxPhi;
   }
 
   const auto meanEta = (minEta + maxEta) / 2.f;
   const auto meanPhi = (minPhi + maxPhi) / 2.f;
   const auto dEta = maxEta - meanEta + m_conf->m_extraEta;
   const auto dPhi = maxPhi - meanPhi + m_conf->m_extraPhi;
 
   auto useCandidates = false;
   if (candidates.first)
     useCandidates = true;
 
   if (useCandidates) {
     // If we have objects used for seeding, loop over objects and find overlap with the found region. Return overlaps as tracking regions to use
     for (const auto& object : *candidates.first) {
       float dEta_Cand = candidates.second.first;
       float dPhi_Cand = candidates.second.second;
       float eta_Cand = object.eta();
       float phi_Cand = object.phi();
       float dEta_Cand_Point = std::abs(eta_Cand - meanEta);
       float dPhi_Cand_Point = std::abs(deltaPhi(phi_Cand, meanPhi));
 
       if (dEta_Cand_Point > (dEta_Cand + dEta) || dPhi_Cand_Point > (dPhi_Cand + dPhi))
         continue;
 
       float etaMin_RoI = std::max(eta_Cand - dEta_Cand, meanEta - dEta);
       float etaMax_RoI = std::min(eta_Cand + dEta_Cand, meanEta + dEta);
 
       float phi_Cand_minus = normalizedPhi(phi_Cand - dPhi_Cand);
       float phi_Point_minus = normalizedPhi(meanPhi - dPhi);
       float phi_Cand_plus = normalizedPhi(phi_Cand + dPhi_Cand);
       float phi_Point_plus = normalizedPhi(meanPhi + dPhi);
 
       float phiMin_RoI = deltaPhi(phi_Cand_minus, phi_Point_minus) > 0. ? phi_Cand_minus : phi_Point_minus;
       float phiMax_RoI = deltaPhi(phi_Cand_plus, phi_Point_plus) < 0. ? phi_Cand_plus : phi_Point_plus;
 
       const auto meanEtaTemp = (etaMin_RoI + etaMax_RoI) / 2.f;
       auto meanPhiTemp = (phiMin_RoI + phiMax_RoI) / 2.f;
       if (phiMax_RoI < phiMin_RoI)
         meanPhiTemp -= M_PI;
       meanPhiTemp = normalizedPhi(meanPhiTemp);
 
       const auto dPhiTemp = deltaPhi(phiMax_RoI, meanPhiTemp);
       const auto dEtaTemp = etaMax_RoI - meanEtaTemp;
 
       const auto x = std::cos(meanPhiTemp);
       const auto y = std::sin(meanPhiTemp);
       const auto z = 1. / std::tan(2.f * std::atan(std::exp(-meanEtaTemp)));
 
       LogTrace("AreaSeededTrackingRegionsBuilder")
           << "Direction x,y,z " << x << "," << y << "," << z << " eta,phi " << meanEtaTemp << "," << meanPhiTemp
           << " window eta " << (meanEtaTemp - dEtaTemp) << "," << (meanEtaTemp + dEtaTemp) << " phi "
           << (meanPhiTemp - dPhiTemp) << "," << (meanPhiTemp + dPhiTemp);
 
       return std::make_unique<RectangularEtaPhiTrackingRegion>(GlobalVector(x, y, z),
                                                                origin.first,  // GlobalPoint
                                                                m_conf->m_ptMin,
                                                                m_conf->m_originRadius,
                                                                origin.second,
                                                                dEtaTemp,
                                                                dPhiTemp,
                                                                *m_field,
                                                                m_msmaker,
                                                                m_conf->m_precise,
                                                                m_conf->m_whereToUseMeasurementTracker,
                                                                m_measurementTracker,
                                                                m_conf->m_searchOpt);
     }
     // Have to retun nullptr here to ensure that we always return something
     return nullptr;
 
   } else {
     const auto x = std::cos(meanPhi);
     const auto y = std::sin(meanPhi);
     const auto z = 1. / std::tan(2.f * std::atan(std::exp(-meanEta)));
 
     LogTrace("AreaSeededTrackingRegionsBuilder")
         << "Direction x,y,z " << x << "," << y << "," << z << " eta,phi " << meanEta << "," << meanPhi << " window eta "
         << (meanEta - dEta) << "," << (meanEta + dEta) << " phi " << (meanPhi - dPhi) << "," << (meanPhi + dPhi);
 
     return std::make_unique<RectangularEtaPhiTrackingRegion>(GlobalVector(x, y, z),
                                                              origin.first,  // GlobalPoint
                                                              m_conf->m_ptMin,
                                                              m_conf->m_originRadius,
                                                              origin.second,
                                                              dEta,
                                                              dPhi,
                                                              *m_field,
                                                              m_msmaker,
                                                              m_conf->m_precise,
                                                              m_conf->m_whereToUseMeasurementTracker,
                                                              m_measurementTracker,
                                                              m_conf->m_searchOpt);
   }
 }

◆ regions()

std::vector< std::unique_ptr< TrackingRegion > > AreaSeededTrackingRegionsBuilder::Builder::regions	(	const Origins &	origins,
		const std::vector< Area > &	areas
	)		const

Definition at line 71 of file AreaSeededTrackingRegionsBuilder.cc.

References LogDebug, eostools::move(), region(), and mps_fire::result.

Referenced by AreaSeededTrackingRegionsProducer::regions().

                                                                 {
   std::vector<std::unique_ptr<TrackingRegion> > result;
 
   // create tracking regions in directions of the points of interest
   int n_regions = 0;
   for (const auto& origin : origins) {
     auto reg = region(origin, areas);
     if (!reg)
       continue;
     result.push_back(std::move(reg));
     ++n_regions;
   }
   LogDebug("AreaSeededTrackingRegionsBuilder") << "produced " << n_regions << " regions";
 
   return result;
 }