PixelTripletHLTGenerator Class Reference

#include <PixelTripletHLTGenerator.h>

Inheritance diagram for PixelTripletHLTGenerator:

Public Member Functions
virtual void	hitTriplets (const TrackingRegion &region, OrderedHitTriplets &trs, const edm::Event &ev, const edm::EventSetup &es, SeedingLayerSetsHits::SeedingLayerSet pairLayers, const std::vector< SeedingLayerSetsHits::SeedingLayer > &thirdLayers) override
	PixelTripletHLTGenerator (const edm::ParameterSet &cfg, edm::ConsumesCollector &iC)
virtual	~PixelTripletHLTGenerator ()
Public Member Functions inherited from HitTripletGeneratorFromPairAndLayers
	HitTripletGeneratorFromPairAndLayers (unsigned int maxElement=0)
	HitTripletGeneratorFromPairAndLayers (const edm::ParameterSet &pset)
void	init (std::unique_ptr< HitPairGeneratorFromLayerPair > &&pairs, LayerCacheType *layerCache)
const HitPairGeneratorFromLayerPair &	pairGenerator () const
virtual	~HitTripletGeneratorFromPairAndLayers ()

Private Types
typedef CombinedHitTripletGenerator::LayerCacheType	LayerCacheType

Private Member Functions
bool	checkPhiInRange (float phi, float phi1, float phi2) const
std::pair< float, float >	mergePhiRanges (const std::pair< float, float > &r1, const std::pair< float, float > &r2) const

Private Attributes
float	dphi
float	extraHitRPhitolerance
float	extraHitRZtolerance
std::unique_ptr< SeedComparitor >	theComparitor
bool	useBend
bool	useFixedPreFiltering
bool	useMScat

Additional Inherited Members
Public Types inherited from HitTripletGeneratorFromPairAndLayers
typedef LayerHitMapCache	LayerCacheType
Protected Attributes inherited from HitTripletGeneratorFromPairAndLayers
LayerCacheType *	theLayerCache
const unsigned int	theMaxElement
std::unique_ptr < HitPairGeneratorFromLayerPair >	thePairGenerator

Detailed Description

Definition at line 20 of file PixelTripletHLTGenerator.h.

Member Typedef Documentation

typedef CombinedHitTripletGenerator::LayerCacheType PixelTripletHLTGenerator::LayerCacheType

private

Definition at line 22 of file PixelTripletHLTGenerator.h.

Constructor & Destructor Documentation

PixelTripletHLTGenerator::PixelTripletHLTGenerator	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &	iC
	)

Definition at line 33 of file PixelTripletHLTGenerator.cc.

References SurfaceDeformationFactory::create(), dphi, reco::get(), edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, theComparitor, and useFixedPreFiltering.

  : HitTripletGeneratorFromPairAndLayers(cfg),
    useFixedPreFiltering(cfg.getParameter<bool>("useFixedPreFiltering")),
    extraHitRZtolerance(cfg.getParameter<double>("extraHitRZtolerance")),
    extraHitRPhitolerance(cfg.getParameter<double>("extraHitRPhitolerance")),
    useMScat(cfg.getParameter<bool>("useMultScattering")),
    useBend(cfg.getParameter<bool>("useBending"))
{
  dphi =  (useFixedPreFiltering) ?  cfg.getParameter<double>("phiPreFiltering") : 0;
  
  edm::ParameterSet comparitorPSet =
    cfg.getParameter<edm::ParameterSet>("SeedComparitorPSet");
  std::string comparitorName = comparitorPSet.getParameter<std::string>("ComponentName");
  if(comparitorName != "none") {
    theComparitor.reset( SeedComparitorFactory::get()->create( comparitorName, comparitorPSet, iC) );
  }
}

PixelTripletHLTGenerator::~PixelTripletHLTGenerator ( )

virtual

Definition at line 51 of file PixelTripletHLTGenerator.cc.

{}

Member Function Documentation

bool PixelTripletHLTGenerator::checkPhiInRange ( float  phi, float  phi1, float  phi2  ) const

private

Definition at line 303 of file PixelTripletHLTGenerator.cc.

References Geom::ftwoPi().

Referenced by hitTriplets().

{
  while (phi > phi2) phi -=  Geom::ftwoPi();
  while (phi < phi1) phi +=  Geom::ftwoPi();
  return (  (phi1 <= phi) && (phi <= phi2) );
}  

void PixelTripletHLTGenerator::hitTriplets ( const TrackingRegion &  region, OrderedHitTriplets &  trs, const edm::Event &  ev, const edm::EventSetup &  es, SeedingLayerSetsHits::SeedingLayerSet  pairLayers, const std::vector< SeedingLayerSetsHits::SeedingLayer > &  thirdLayers  )

overridevirtual

Implements HitTripletGeneratorFromPairAndLayers.

Definition at line 53 of file PixelTripletHLTGenerator.cc.

References angle(), KDTreeLinkerAlgo< DATA >::build(), checkPhiInRange(), constexpr, PixelRecoUtilities::curvature(), dphi, relativeConstraints::empty, ev, extraHitRPhitolerance, extraHitRZtolerance, f, Geom::fpi(), Geom::ftwoPi(), i, ThirdHitRZPredictionBase::initLayer(), ThirdHitRZPrediction< Propagator >::initPropagator(), ThirdHitRZPredictionBase::initTolerance(), HitDoublets::inner, PixelRecoRange< T >::intersection(), DetLayer::isBarrel(), geometryCSVtoXML::line, LogDebug, bookConverter::max, mergePhiRanges(), min(), nSigmaPhi, nSigmaRZ, TrackingRegion::origin(), TrackingRegion::originRBound(), HitDoublets::outer, PV3DBase< T, PVType, FrameType >::perp(), TrackingRegion::ptMin(), CosmicsPD_Skims::radius, HLT_25ns14e33_v3_cff::region, KDTreeLinkerAlgo< DATA >::search(), OrderedHitTriplets::size(), findQualityFiles::size, swap(), theComparitor, HitTripletGeneratorFromPairAndLayers::theMaxElement, HitTripletGeneratorFromPairAndLayers::thePairGenerator, useBend, useFixedPreFiltering, useMScat, findQualityFiles::v, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

{

  if (theComparitor) theComparitor->init(ev, es);
  
  auto const & doublets = thePairGenerator->doublets(region,ev,es, pairLayers);
  
  if (doublets.empty()) return;

  auto outSeq =  doublets.detLayer(HitDoublets::outer)->seqNum();


  // std::cout << "pairs " << doublets.size() << std::endl;
  
  float regOffset = region.origin().perp(); //try to take account of non-centrality (?)
  int size = thirdLayers.size();
  
  #ifdef __clang__
  std::vector<ThirdHitRZPrediction<PixelRecoLineRZ>> preds(size);
  #else
  ThirdHitRZPrediction<PixelRecoLineRZ> preds[size];
  #endif
  
  const RecHitsSortedInPhi * thirdHitMap[size];
  typedef RecHitsSortedInPhi::Hit Hit;

  using NodeInfo = KDTreeNodeInfo<unsigned int>;
  std::vector<NodeInfo > layerTree; // re-used throughout
  std::vector<unsigned int> foundNodes; // re-used thoughout
  foundNodes.reserve(100);

  #ifdef __clang__
  std::vector<KDTreeLinkerAlgo<unsigned int>> hitTree(size);
  #else
  KDTreeLinkerAlgo<unsigned int> hitTree[size];
  #endif
  float rzError[size]; //save maximum errors
  float maxphi = Geom::ftwoPi(), minphi = -maxphi; // increase to cater for any range
  
  // fill the prediction vector
  for (int il=0; il!=size; ++il) {
    thirdHitMap[il] = &(*theLayerCache)(thirdLayers[il], region, ev, es);
    auto const & hits = *thirdHitMap[il];
    ThirdHitRZPrediction<PixelRecoLineRZ> & pred = preds[il];
    pred.initLayer(thirdLayers[il].detLayer());
    pred.initTolerance(extraHitRZtolerance);
    
    layerTree.clear();
    float minv=999999.0, maxv= -999999.0; // Initialise to extreme values in case no hits
    float maxErr=0.0f;
    for (unsigned int i=0; i!=hits.size(); ++i) {
      auto angle = hits.phi(i);
      auto v =  hits.gv(i);
      //use (phi,r) for endcaps rather than (phi,z)
      minv = std::min(minv,v);  maxv = std::max(maxv,v);
      float myerr = hits.dv[i];
      maxErr = std::max(maxErr,myerr);
      layerTree.emplace_back(i, angle, v); // save it
      if (angle < 0)  // wrap all points in phi
    { layerTree.emplace_back(i, angle+Geom::ftwoPi(), v);}
      else
    { layerTree.emplace_back(i, angle-Geom::ftwoPi(), v);}
    }
    KDTreeBox phiZ(minphi, maxphi, minv-0.01f, maxv+0.01f);  // declare our bounds
    //add fudge factors in case only one hit and also for floating-point inaccuracy
    hitTree[il].build(layerTree, phiZ); // make KDtree
    rzError[il] = maxErr; //save error
    // std::cout << "layer " << thirdLayers[il].detLayer()->seqNum() << " " << layerTree.size() << std::endl; 
  }
  
  float imppar = region.originRBound();
  float imppartmp = region.originRBound()+region.origin().perp();
  float curv = PixelRecoUtilities::curvature(1.f/region.ptMin(), es);
  
  for (std::size_t ip =0;  ip!=doublets.size(); ip++) {
    auto xi = doublets.x(ip,HitDoublets::inner);
    auto yi = doublets.y(ip,HitDoublets::inner);
    auto zi = doublets.z(ip,HitDoublets::inner);
    auto rvi = doublets.rv(ip,HitDoublets::inner);
    auto xo = doublets.x(ip,HitDoublets::outer);
    auto yo = doublets.y(ip,HitDoublets::outer);
    auto zo = doublets.z(ip,HitDoublets::outer);
    auto rvo = doublets.rv(ip,HitDoublets::outer);
    
    PixelRecoPointRZ point1(rvi, zi);
    PixelRecoPointRZ point2(rvo, zo);
    PixelRecoLineRZ  line(point1, point2);
    ThirdHitPredictionFromInvParabola predictionRPhi(xi-region.origin().x(),yi-region.origin().y(),
                             xo-region.origin().x(),yo-region.origin().y(),
                             imppar,curv,extraHitRPhitolerance);

    ThirdHitPredictionFromInvParabola predictionRPhitmp(xi,yi,xo,yo,imppartmp,curv,extraHitRPhitolerance);

    // printf("++Constr %f %f %f %f %f %f %f\n",xi,yi,xo,yo,imppartmp,curv,extraHitRPhitolerance);     

    // std::cout << ip << ": " << point1.r() << ","<< point1.z() << " " 
    //                        << point2.r() << ","<< point2.z() <<std::endl;

    for (int il=0; il!=size; ++il) {
      if (hitTree[il].empty()) continue; // Don't bother if no hits
      
      auto const & hits = *thirdHitMap[il];
      
      const DetLayer * layer = thirdLayers[il].detLayer();
      auto barrelLayer = layer->isBarrel();

      ThirdHitCorrection correction(es, region.ptMin(), layer, line, point2, outSeq, useMScat, useBend); 
      
      ThirdHitRZPrediction<PixelRecoLineRZ> & predictionRZ =  preds[il];
      
      predictionRZ.initPropagator(&line);
      Range rzRange = predictionRZ();
      correction.correctRZRange(rzRange);
      
      Range phiRange;
      if (useFixedPreFiltering) { 
    float phi0 = doublets.phi(ip,HitDoublets::outer);
    phiRange = Range(phi0-dphi,phi0+dphi);
      }
      else {
    Range radius;
    if (barrelLayer) {
      radius =  predictionRZ.detRange();
    } else {
      radius = Range(max(rzRange.min(), predictionRZ.detSize().min()),
             min(rzRange.max(), predictionRZ.detSize().max()) );
    }
    if (radius.empty()) continue;

    // std::cout << "++R " << radius.min() << " " << radius.max()  << std::endl;

    /*
    Range rPhi1m = predictionRPhitmp(radius.max(), -1);
    Range rPhi1p = predictionRPhitmp(radius.max(),  1);
    Range rPhi2m = predictionRPhitmp(radius.min(), -1);
    Range rPhi2p = predictionRPhitmp(radius.min(),  1);
    Range rPhi1 = rPhi1m.sum(rPhi1p);
    Range rPhi2 = rPhi2m.sum(rPhi2p);
    
    
    auto rPhi1N = predictionRPhitmp(radius.max());
    auto rPhi2N = predictionRPhitmp(radius.min());

    std::cout << "VI " 
          << rPhi1N.first <<'/'<< rPhi1.first << ' '
          << rPhi1N.second <<'/'<< rPhi1.second << ' '
          << rPhi2N.first <<'/'<< rPhi2.first << ' '
          << rPhi2N.second <<'/'<< rPhi2.second
          << std::endl;
    
    */

    auto rPhi1 = predictionRPhitmp(radius.max());
    auto rPhi2 = predictionRPhitmp(radius.min());


    correction.correctRPhiRange(rPhi1);
    correction.correctRPhiRange(rPhi2);
    rPhi1.first  /= radius.max();
    rPhi1.second /= radius.max();
    rPhi2.first  /= radius.min();
    rPhi2.second /= radius.min();
    phiRange = mergePhiRanges(rPhi1,rPhi2);
      }
      
      constexpr float nSigmaRZ = 3.46410161514f; // std::sqrt(12.f); // ...and continue as before
      constexpr float nSigmaPhi = 3.f;
      
      foundNodes.clear(); // Now recover hits in bounding box...
      float prmin=phiRange.min(), prmax=phiRange.max();
      if ((prmax-prmin) > Geom::ftwoPi())
    { prmax=Geom::fpi(); prmin = -Geom::fpi();}
      else
    { while (prmax>maxphi) { prmin -= Geom::ftwoPi(); prmax -= Geom::ftwoPi();}
      while (prmin<minphi) { prmin += Geom::ftwoPi(); prmax += Geom::ftwoPi();}
      // This needs range -twoPi to +twoPi to work
    }
      if (barrelLayer)
    {
      Range regMax = predictionRZ.detRange();
      Range regMin = predictionRZ(regMax.min()-regOffset);
      regMax = predictionRZ(regMax.max()+regOffset);
      correction.correctRZRange(regMin);
      correction.correctRZRange(regMax);
      if (regMax.min() < regMin.min()) { swap(regMax, regMin);}
      KDTreeBox phiZ(prmin, prmax, regMin.min()-nSigmaRZ*rzError[il], regMax.max()+nSigmaRZ*rzError[il]);
      hitTree[il].search(phiZ, foundNodes);
    }
      else
    {
      KDTreeBox phiZ(prmin, prmax,
             rzRange.min()-regOffset-nSigmaRZ*rzError[il],
             rzRange.max()+regOffset+nSigmaRZ*rzError[il]);
      hitTree[il].search(phiZ, foundNodes);
    }

      // std::cout << ip << ": " << thirdLayers[il].detLayer()->seqNum() << " " << foundNodes.size() << " " << prmin << " " << prmax << std::endl;


      // int kk=0;
      for (auto KDdata : foundNodes) {
    
    if (theMaxElement!=0 && result.size() >= theMaxElement){
      result.clear();
      edm::LogError("TooManyTriplets")<<" number of triples exceeds maximum. no triplets produced.";
      return;
    }
    
    float p3_u = hits.u[KDdata]; 
    float p3_v =  hits.v[KDdata]; 
    float p3_phi =  hits.lphi[KDdata]; 

       //if ((kk++)%100==0)
       //std::cout << kk << ": " << p3_u << " " << p3_v << " " << p3_phi << std::endl;

    
    Range allowed = predictionRZ(p3_u);
    correction.correctRZRange(allowed);
    float vErr = nSigmaRZ *hits.dv[KDdata];
    Range hitRange(p3_v-vErr, p3_v+vErr);
    Range crossingRange = allowed.intersection(hitRange);
    if (crossingRange.empty())  continue;
    
    float ir = 1.f/hits.rv(KDdata);
    float phiErr = nSigmaPhi * hits.drphi[KDdata]*ir;
    for (int icharge=-1; icharge <=1; icharge+=2) {
      Range rangeRPhi = predictionRPhi(hits.rv(KDdata), icharge);
      correction.correctRPhiRange(rangeRPhi);
      if (checkPhiInRange(p3_phi, rangeRPhi.first*ir-phiErr, rangeRPhi.second*ir+phiErr)) {
        // insert here check with comparitor
        OrderedHitTriplet hittriplet( doublets.hit(ip,HitDoublets::inner), doublets.hit(ip,HitDoublets::outer), hits.theHits[KDdata].hit());
        if (!theComparitor  || theComparitor->compatible(hittriplet,region) ) {
          result.push_back( hittriplet );
        } else {
          LogDebug("RejectedTriplet") << "rejected triplet from comparitor ";
        }
        break;
      } 
    }
      }
    }
  }
  // std::cout << "triplets " << result.size() << std::endl;
}

std::pair< float, float > PixelTripletHLTGenerator::mergePhiRanges ( const std::pair< float, float > &  r1, const std::pair< float, float > &  r2  ) const

private

Definition at line 310 of file PixelTripletHLTGenerator.cc.

References Geom::fpi(), Geom::ftwoPi(), bookConverter::max, and min().

Referenced by hitTriplets().

{ float r2_min=r2.first;
  float r2_max=r2.second;
  while (r1.first-r2_min > Geom::fpi()) { r2_min += Geom::ftwoPi(); r2_max += Geom::ftwoPi();}
  while (r1.first-r2_min < -Geom::fpi()) { r2_min -= Geom::ftwoPi();  r2_max -= Geom::ftwoPi(); }
  
  return std::make_pair(min(r1.first,r2_min),max(r1.second,r2_max));
}

Member Data Documentation

float PixelTripletHLTGenerator::dphi

private

Definition at line 45 of file PixelTripletHLTGenerator.h.

Referenced by hitTriplets(), and PixelTripletHLTGenerator().

float PixelTripletHLTGenerator::extraHitRPhitolerance

private

Definition at line 42 of file PixelTripletHLTGenerator.h.

Referenced by hitTriplets().

float PixelTripletHLTGenerator::extraHitRZtolerance

private

Definition at line 41 of file PixelTripletHLTGenerator.h.

Referenced by hitTriplets().

std::unique_ptr<SeedComparitor> PixelTripletHLTGenerator::theComparitor

private

Definition at line 46 of file PixelTripletHLTGenerator.h.

Referenced by hitTriplets(), and PixelTripletHLTGenerator().

bool PixelTripletHLTGenerator::useBend

private

Definition at line 44 of file PixelTripletHLTGenerator.h.

Referenced by hitTriplets().

bool PixelTripletHLTGenerator::useFixedPreFiltering

private

Definition at line 40 of file PixelTripletHLTGenerator.h.

Referenced by hitTriplets(), and PixelTripletHLTGenerator().

bool PixelTripletHLTGenerator::useMScat

private

Definition at line 43 of file PixelTripletHLTGenerator.h.

Referenced by hitTriplets().