#include <AreaSeededTrackingRegionsBuilder.h>

Public Member Functions
	Builder (const AreaSeededTrackingRegionsBuilder *conf)

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 = 0

const MeasurementTrackerEvent *	m_measurementTracker = 0

Detailed Description

Definition at line 76 of file AreaSeededTrackingRegionsBuilder.h.

Constructor & Destructor Documentation

AreaSeededTrackingRegionsBuilder::Builder::Builder ( const AreaSeededTrackingRegionsBuilder * conf )

inlineexplicit

Definition at line 78 of file AreaSeededTrackingRegionsBuilder.h.

78 : m_conf(conf) {}

AreaSeededTrackingRegionsBuilder::Builder::m_conf

const AreaSeededTrackingRegionsBuilder * m_conf

Definition: AreaSeededTrackingRegionsBuilder.h:92

AreaSeededTrackingRegionsBuilder::Builder::~Builder ( )

default

Member Function Documentation

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

Definition at line 79 of file AreaSeededTrackingRegionsBuilder.cc.

                                                                                                                                       {
   return regionImpl(origin, areas);
 }

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

Definition at line 82 of file AreaSeededTrackingRegionsBuilder.cc.

                                                                                                                                            {
   return regionImpl(origin, areas);
 }

template<typename T >

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

private

Definition at line 87 of file AreaSeededTrackingRegionsBuilder.cc.

References funct::abs(), custom_jme_cff::area, objects.IsoTrackAnalyzer::candidates, funct::cos(), edmIntegrityCheck::d, reco::deltaPhi(), hiPixelPairStep_cff::deltaPhi, particleFlow_cfi::dEta, particleFlow_cfi::dPhi, JetChargeProducer_cfi::exp, f, LogDebug, LogTrace, M_PI, SiStripPI::max, maxEta, trackingParticleSelector_cfi::maxPhi, min(), trackingPOGFilters_cfi::minEta, trackingParticleSelector_cfi::minPhi, normalizedPhi(), perp2(), phimax, phimin, alignCSCRings::r, Validation_hcalonly_cfi::sign, funct::sin(), mathSSE::sqrt(), funct::tan(), 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_conf->m_whereToUseMeasurementTracker,
                 m_conf->m_precise,
                 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_conf->m_whereToUseMeasurementTracker,
             m_conf->m_precise,
             m_measurementTracker,
             m_conf->m_searchOpt
     );  
   }
 }

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

Definition at line 63 of file AreaSeededTrackingRegionsBuilder.cc.

References LogDebug, eostools::move(), 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;
 }