CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
RoadSearchSeedFinderAlgorithm.cc
Go to the documentation of this file.
1 //
2 // Package: RecoTracker/RoadSearchSeedFinder
3 // Class: RoadSearchSeedFinderAlgorithm
4 //
5 // Description: Loops over Roads, checks for every
6 // RoadSeed if hits are in the inner and
7 // outer SeedRing, applies cuts for all
8 // combinations of inner and outer SeedHits,
9 // stores valid combination in TrajectorySeed
10 //
11 // Original Author: Oliver Gutsche, gutsche@fnal.gov
12 // Created: Sat Jan 14 22:00:00 UTC 2006
13 //
14 // $Author: gpetrucc $
15 // $Date: 2009/05/23 10:31:34 $
16 // $Revision: 1.35 $
17 //
18 
19 #include <vector>
20 #include <iostream>
21 #include <cmath>
22 #include <algorithm>
23 
25 
27 
31 
34 
38 
40 
42 
52 
56 //***top-bottom
58 //***
59 const double speedOfLight = 2.99792458e8;
60 const double unitCorrection = speedOfLight * 1e-2 * 1e-9;
61 
63 
64 
65  minPt_ = conf.getParameter<double>("MinimalReconstructedTransverseMomentum");
66  maxBarrelImpactParameter_ = conf.getParameter<double>("MaximalBarrelImpactParameter");
67  maxEndcapImpactParameter_ = conf.getParameter<double>("MaximalEndcapImpactParameter");
68  phiRangeDetIdLookup_ = conf.getParameter<double>("PhiRangeForDetIdLookupInRings");
69  mergeSeedsCenterCut_A_ = conf.getParameter<double>("MergeSeedsCenterCut_A");
70  mergeSeedsRadiusCut_A_ = conf.getParameter<double>("MergeSeedsRadiusCut_A");
71  mergeSeedsCenterCut_B_ = conf.getParameter<double>("MergeSeedsCenterCut_B");
72  mergeSeedsRadiusCut_B_ = conf.getParameter<double>("MergeSeedsRadiusCut_B");
73  mergeSeedsCenterCut_C_ = conf.getParameter<double>("MergeSeedsCenterCut_C");
74  mergeSeedsRadiusCut_C_ = conf.getParameter<double>("MergeSeedsRadiusCut_C");
77  mergeSeedsDifferentHitsCut_ = conf.getParameter<unsigned int>("MergeSeedsDifferentHitsCut");
78  mode_ = conf.getParameter<std::string>("Mode");
79 
80  //special parameters for cosmic track reconstruction
81  //cosmicTracking_ = conf.getParameter<bool>("CosmicTracking");
82  //maxNumberOfClusters_ = conf.getParameter<unsigned int>("MaxNumberOfClusters");
83 
84 
85  // safety check for mode
86  if ( mode_ != "STANDARD" && mode_ != "STRAIGHT-LINE" ) {
87  mode_ = "STANDARD";
88  }
89 
90  std::string tmp = conf.getParameter<std::string>("InnerSeedRecHitAccessMode");
91  if ( tmp == "STANDARD" ) {
93  } else if ( tmp == "RPHI" ) {
95  } else {
97  }
98  innerSeedHitAccessUseRPhi_ = conf.getParameter<bool>("InnerSeedRecHitAccessUseRPhi");
99  innerSeedHitAccessUseStereo_ = conf.getParameter<bool>("InnerSeedRecHitAccessUseStereo");
100 
101  tmp = conf.getParameter<std::string>("OuterSeedRecHitAccessMode");
102  if ( tmp == "STANDARD" ) {
104  } else if ( tmp == "RPHI" ) {
106  } else {
108  }
109  outerSeedHitAccessUseRPhi_ = conf.getParameter<bool>("OuterSeedRecHitAccessUseRPhi");
110  outerSeedHitAccessUseStereo_ = conf.getParameter<bool>("OuterSeedRecHitAccessUseStereo");
111 
112  // configure DetHitAccess
115  innerSeedHitVector_.use_stereoRecHits(innerSeedHitAccessUseStereo_);
118  outerSeedHitVector_.use_stereoRecHits(outerSeedHitAccessUseStereo_);
119 
120  roadsLabel_ = conf.getParameter<std::string>("RoadsLabel");
121 
122  maxNumberOfSeeds_ = conf.getParameter<int32_t>("MaxNumberOfSeeds");
123  //***top-bottom
124  allPositiveOnly = conf.getParameter<bool>("AllPositiveOnly");
125  allNegativeOnly = conf.getParameter<bool>("AllNegativeOnly");
126  //***
127 }
128 
130 }
131 
132 
137  const edm::EventSetup& es,
139 {
140 
141  // initialize general hit access for road search
142  innerSeedHitVector_.setCollections(rphiRecHits,stereoRecHits,matchedRecHits,pixelRecHits);
143  outerSeedHitVector_.setCollections(rphiRecHits,stereoRecHits,matchedRecHits,pixelRecHits);
144 
145  // get roads
147  es.get<RoadMapRecord>().get(roadsLabel_,roads);
148  roads_ = roads.product();
149 
150  // get tracker geometry
152  es.get<TrackerDigiGeometryRecord>().get(tracker);
153  tracker_ = tracker.product();
154 
155  // get magnetic field
156  edm::ESHandle<MagneticField> magnetHandle;
157  es.get<IdealMagneticFieldRecord>().get(magnetHandle);
158  magnet_ = magnetHandle.product();
159 
160  //***top-bottom
161  //TTRHBuilder
162  TkTransientTrackingRecHitBuilder builder(tracker_,0,0,0,false);
163  //***
164 
165  // get magnetic field for 0,0,0 , approximation for minRadius calculation
167  // calculate minimal radius at globalPoint in cm, take the z component of the magnetic field at GlobalPoint 2
168  if ( beamSpotZMagneticField_ == 0 ) {
169  minRadius_ = 999999999999.;
170  } else {
171  minRadius_ = minPt_ / 0.3 / beamSpotZMagneticField_ * 100;
172  }
173 
174  // temporary storing collection of circle seeds
175  std::vector<RoadSearchCircleSeed> localCircleSeeds;
176 
177  // loop over seed Ring pairs
178  for ( Roads::const_iterator road = roads_->begin(); road != roads_->end(); ++road ) {
179 
180  localCircleSeeds.clear();
181 
182  const Roads::RoadSeed *seed = &((*road).first);
183  const Roads::RoadSet *set = &((*road).second);
184 
185  // determine seeding cuts from inner seed ring |eta|
186  double r = std::abs((*seed->first.begin())->getrmax() + (*seed->first.begin())->getrmin())/2.;
187  double z = std::abs((*seed->first.begin())->getzmax() + (*seed->first.begin())->getzmin())/2.;
188  double eta = std::abs(std::log(std::tan(std::atan2(r,z)/2.)));
189 
190  if ( eta < 1.1 ) {
193  } else if ( (eta >= 1.1) && (eta < 1.6) ) {
196  } else if ( eta >= 1.6 ) {
199  }
200 
201  if ( mode_ == "STRAIGHT-LINE" ) {
202 
203  // loop over seed ring pairs
204  // draw straight line
205  for ( std::vector<const Ring*>::const_iterator innerSeedRing = seed->first.begin();
206  innerSeedRing != seed->first.end();
207  ++innerSeedRing) {
208  for ( std::vector<const Ring*>::const_iterator outerSeedRing = seed->second.begin();
209  outerSeedRing != seed->second.end();
210  ++outerSeedRing) {
212  seed,
213  set,
214  *innerSeedRing,
215  *outerSeedRing);
216 
217  }
218  }
219  } else if ( mode_ == "STANDARD" ) {
220 
221  // take combinations of one inner and two outer or two inner and one outer seed ring
222  for ( std::vector<const Ring*>::const_iterator innerSeedRing1 = seed->first.begin();
223  innerSeedRing1 != seed->first.end();
224  ++innerSeedRing1) {
225  // two inner, one outer
226  for ( std::vector<const Ring*>::const_iterator innerSeedRing2 = innerSeedRing1+1;
227  innerSeedRing2 != seed->first.end();
228  ++innerSeedRing2) {
229  if ( !ringsOnSameLayer(*innerSeedRing1,*innerSeedRing2) ) {
230  for ( std::vector<const Ring*>::const_iterator outerSeedRing = seed->second.begin();
231  outerSeedRing != seed->second.end();
232  ++outerSeedRing) {
233  // calculate seed ring combination identifier
234  unsigned int identifier = (*innerSeedRing1)->getindex() * 1000000 +
235  (*innerSeedRing2)->getindex() * 1000 +
236  (*outerSeedRing)->getindex();
237  bool check = true;
238  for ( std::vector<unsigned int>::iterator alreadyChecked = usedSeedRingCombinations_.begin();
239  alreadyChecked != usedSeedRingCombinations_.end();
240  ++alreadyChecked ) {
241  if ( identifier == *alreadyChecked ) {
242  check = false;
243  break;
244  }
245  }
246 
247  if ( check ) {
248  usedSeedRingCombinations_.push_back(identifier);
250  seed,
251  set,
252  *innerSeedRing1,
253  *innerSeedRing2,
254  *outerSeedRing);
255  }
256  }
257  }
258  }
259  // one inner, two outer
260  for ( std::vector<const Ring*>::const_iterator outerSeedRing1 = seed->second.begin();
261  outerSeedRing1 != seed->second.end();
262  ++outerSeedRing1) {
263  for ( std::vector<const Ring*>::const_iterator outerSeedRing2 = outerSeedRing1+1;
264  outerSeedRing2 != seed->second.end();
265  ++outerSeedRing2) {
266  if ( !ringsOnSameLayer(*outerSeedRing1,*outerSeedRing2) ) {
267  // calculate seed ring combination identifier
268  unsigned int identifier = (*innerSeedRing1)->getindex() * 1000000 +
269  (*outerSeedRing1)->getindex() * 1000 +
270  (*outerSeedRing2)->getindex();
271  bool check = true;
272  for ( std::vector<unsigned int>::iterator alreadyChecked = usedSeedRingCombinations_.begin();
273  alreadyChecked != usedSeedRingCombinations_.end();
274  ++alreadyChecked ) {
275  if ( identifier == *alreadyChecked ) {
276  check = false;
277  break;
278  }
279  }
280 
281  if ( check ) {
282  usedSeedRingCombinations_.push_back(identifier);
284  seed,
285  set,
286  *innerSeedRing1,
287  *outerSeedRing1,
288  *outerSeedRing2);
289  }
290  }
291  }
292  }
293  }
294  }
295 
296  // fill in eta mapped multi-map
297  for ( std::vector<RoadSearchCircleSeed>::iterator localCircle = localCircleSeeds.begin(),
298  localCircleEnd = localCircleSeeds.end();
299  localCircle != localCircleEnd;
300  ++localCircle ) {
301  RoadSearchSeed seed;
302  seed.setSet(localCircle->getSet());
303  seed.setSeed(localCircle->getSeed());
304  //***top-bottom
305  bool allPositive = true;
306  bool allNegative = true;
307  //***
308  for (std::vector<const TrackingRecHit*>::const_iterator hit = localCircle->begin_hits();
309  hit != localCircle->end_hits();
310  ++hit ) {
311  seed.addHit(*hit);
312  //***top-bottom
313  double seedY = builder.build(*hit)->globalPosition().y();
314  if (seedY>0) allNegative = false;
315  if (seedY<0) allPositive = false;
316  //***
317  }
318  //***top-bottom
319  //output.push_back(seed);
320  if (allPositive && allPositiveOnly) output.push_back(seed);
321  if (allNegative && allNegativeOnly) output.push_back(seed);
322  if (!allPositiveOnly && !allNegativeOnly) output.push_back(seed);
323  //***
324  }
325 
326  if ((maxNumberOfSeeds_ > 0) && (output.size() > size_t(maxNumberOfSeeds_))) {
327  edm::LogError("TooManySeeds") << "Found too many seeds, bailing out.\n";
328  output.clear();
329  break;
330  }
331  }
332 
334  edm::LogInfo("RoadSearch") << "Found " << output.size() << " seeds.";
335 
336 }
337 
338 bool RoadSearchSeedFinderAlgorithm::calculateCircleSeedsFromRingsTwoInnerOneOuter(std::vector<RoadSearchCircleSeed> &circleSeeds,
339  const Roads::RoadSeed *seed,
340  const Roads::RoadSet *set,
341  const Ring* ring1,
342  const Ring* ring2,
343  const Ring* ring3) {
344  //
345  // calculate RoadSearchCircleSeed
346  //
347  // apply circle seed cuts
348  //
349 
350  // return value
351  bool result = true;
352 
353  // loop over detid's in first rings
354  for ( Ring::const_iterator ring1DetIdIterator = ring1->begin();
355  ring1DetIdIterator != ring1->end();
356  ++ring1DetIdIterator ) {
357 
358  DetId ring1DetId = ring1DetIdIterator->second;
359  std::vector<TrackingRecHit*> ring1RecHits = innerSeedHitVector_.getHitVector(&ring1DetId);
360 
361  // loop over inner rechits
362  for (std::vector<TrackingRecHit*>::const_iterator ring1RecHit = ring1RecHits.begin();
363  ring1RecHit != ring1RecHits.end();
364  ++ring1RecHit) {
365 
366  GlobalPoint ring1GlobalPoint = tracker_->idToDet((*ring1RecHit)->geographicalId())->surface().toGlobal((*ring1RecHit)->localPosition());
367 
368  // calculate phi range around inner hit
369  double innerphi = ring1GlobalPoint.phi();
370  double upperPhiRangeBorder = innerphi + phiRangeDetIdLookup_;
371  double lowerPhiRangeBorder = innerphi - phiRangeDetIdLookup_;
372  if (upperPhiRangeBorder>Geom::pi()) upperPhiRangeBorder -= Geom::twoPi();
373  if (lowerPhiRangeBorder<(-Geom::pi())) lowerPhiRangeBorder += Geom::twoPi();
374 
375  // retrieve vectors of TrackingRecHits in ring2 and ring3 in phi range
376  std::vector<TrackingRecHit*> ring2RecHits;
377  std::vector<TrackingRecHit*> ring3RecHits;
378 
379  if (lowerPhiRangeBorder <= upperPhiRangeBorder ) {
380  for ( Ring::const_iterator outerRingDetId = ring2->lower_bound(lowerPhiRangeBorder);
381  outerRingDetId != ring2->upper_bound(upperPhiRangeBorder);
382  ++outerRingDetId) {
383  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
384  ring2RecHits.insert(ring2RecHits.end(),
385  rings.begin(),
386  rings.end());
387  }
388  for ( Ring::const_iterator outerRingDetId = ring3->lower_bound(lowerPhiRangeBorder);
389  outerRingDetId != ring3->upper_bound(upperPhiRangeBorder);
390  ++outerRingDetId) {
391  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
392  ring3RecHits.insert(ring3RecHits.end(),
393  rings.begin(),
394  rings.end());
395  }
396  } else {
397  for ( Ring::const_iterator outerRingDetId = ring2->begin();
398  outerRingDetId != ring2->upper_bound(upperPhiRangeBorder);
399  ++outerRingDetId) {
400  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
401  ring2RecHits.insert(ring2RecHits.end(),
402  rings.begin(),
403  rings.end());
404  }
405  for ( Ring::const_iterator outerRingDetId = ring3->begin();
406  outerRingDetId != ring3->upper_bound(upperPhiRangeBorder);
407  ++outerRingDetId) {
408  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
409  ring3RecHits.insert(ring3RecHits.end(),
410  rings.begin(),
411  rings.end());
412  }
413  for ( Ring::const_iterator outerRingDetId = ring2->lower_bound(lowerPhiRangeBorder);
414  outerRingDetId != ring2->end();
415  ++outerRingDetId) {
416  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
417  ring2RecHits.insert(ring2RecHits.end(),
418  rings.begin(),
419  rings.end());
420  }
421  for ( Ring::const_iterator outerRingDetId = ring3->lower_bound(lowerPhiRangeBorder);
422  outerRingDetId != ring3->end();
423  ++outerRingDetId) {
424  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
425  ring3RecHits.insert(ring3RecHits.end(),
426  rings.begin(),
427  rings.end());
428  }
429  }
430 
431  if ( ring2RecHits.size() > 0 &&
432  ring3RecHits.size() > 0 ) {
433  calculateCircleSeedsFromHits(circleSeeds, seed, set, ring1GlobalPoint, *ring1RecHit, ring2RecHits, ring3RecHits);
434  }
435 
436  }
437  }
438 
439  return result;
440 
441 }
442 
443 bool RoadSearchSeedFinderAlgorithm::calculateCircleSeedsFromRingsOneInnerTwoOuter(std::vector<RoadSearchCircleSeed> &circleSeeds,
444  const Roads::RoadSeed *seed,
445  const Roads::RoadSet *set,
446  const Ring* ring1,
447  const Ring* ring2,
448  const Ring* ring3) {
449  //
450  // calculate RoadSearchCircleSeed
451  //
452  // apply circle seed cuts
453  //
454 
455  // return value
456  bool result = true;
457 
458  // loop over detid's in first rings
459  for ( Ring::const_iterator ring1DetIdIterator = ring1->begin();
460  ring1DetIdIterator != ring1->end();
461  ++ring1DetIdIterator ) {
462 
463  DetId ring1DetId = ring1DetIdIterator->second;
464  std::vector<TrackingRecHit*> ring1RecHits = innerSeedHitVector_.getHitVector(&ring1DetId);
465 
466  // loop over inner rechits
467  for (std::vector<TrackingRecHit*>::const_iterator ring1RecHit = ring1RecHits.begin();
468  ring1RecHit != ring1RecHits.end();
469  ++ring1RecHit) {
470 
471  GlobalPoint ring1GlobalPoint = tracker_->idToDet((*ring1RecHit)->geographicalId())->surface().toGlobal((*ring1RecHit)->localPosition());
472 
473  // calculate phi range around inner hit
474  double innerphi = ring1GlobalPoint.phi();
475  double upperPhiRangeBorder = innerphi + phiRangeDetIdLookup_;
476  double lowerPhiRangeBorder = innerphi - phiRangeDetIdLookup_;
477  if (upperPhiRangeBorder>Geom::pi()) upperPhiRangeBorder -= Geom::twoPi();
478  if (lowerPhiRangeBorder<(-Geom::pi())) lowerPhiRangeBorder += Geom::twoPi();
479 
480  // retrieve vectors of TrackingRecHits in ring2 and ring3 in phi range
481  std::vector<TrackingRecHit*> ring2RecHits;
482  std::vector<TrackingRecHit*> ring3RecHits;
483 
484  if (lowerPhiRangeBorder <= upperPhiRangeBorder ) {
485  for ( Ring::const_iterator outerRingDetId = ring2->lower_bound(lowerPhiRangeBorder);
486  outerRingDetId != ring2->upper_bound(upperPhiRangeBorder);
487  ++outerRingDetId) {
488  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
489  ring2RecHits.insert(ring2RecHits.end(),
490  rings.begin(),
491  rings.end());
492  }
493  for ( Ring::const_iterator outerRingDetId = ring3->lower_bound(lowerPhiRangeBorder);
494  outerRingDetId != ring3->upper_bound(upperPhiRangeBorder);
495  ++outerRingDetId) {
496  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
497  ring3RecHits.insert(ring3RecHits.end(),
498  rings.begin(),
499  rings.end());
500  }
501  } else {
502  for ( Ring::const_iterator outerRingDetId = ring2->begin();
503  outerRingDetId != ring2->upper_bound(upperPhiRangeBorder);
504  ++outerRingDetId) {
505  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
506  ring2RecHits.insert(ring2RecHits.end(),
507  rings.begin(),
508  rings.end());
509  }
510  for ( Ring::const_iterator outerRingDetId = ring3->begin();
511  outerRingDetId != ring3->upper_bound(upperPhiRangeBorder);
512  ++outerRingDetId) {
513  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
514  ring3RecHits.insert(ring3RecHits.end(),
515  rings.begin(),
516  rings.end());
517  }
518  for ( Ring::const_iterator outerRingDetId = ring2->lower_bound(lowerPhiRangeBorder);
519  outerRingDetId != ring2->end();
520  ++outerRingDetId) {
521  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
522  ring2RecHits.insert(ring2RecHits.end(),
523  rings.begin(),
524  rings.end());
525  }
526  for ( Ring::const_iterator outerRingDetId = ring3->lower_bound(lowerPhiRangeBorder);
527  outerRingDetId != ring3->end();
528  ++outerRingDetId) {
529  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
530  ring3RecHits.insert(ring3RecHits.end(),
531  rings.begin(),
532  rings.end());
533  }
534  }
535 
536  if ( ring2RecHits.size() > 0 &&
537  ring3RecHits.size() > 0 ) {
538  calculateCircleSeedsFromHits(circleSeeds, seed, set, ring1GlobalPoint, *ring1RecHit, ring2RecHits, ring3RecHits);
539  }
540 
541  }
542  }
543 
544  return result;
545 
546 }
547 
548 bool RoadSearchSeedFinderAlgorithm::calculateCircleSeedsFromRingsOneInnerOneOuter(std::vector<RoadSearchCircleSeed> &circleSeeds,
549  const Roads::RoadSeed *seed,
550  const Roads::RoadSet *set,
551  const Ring* ring1,
552  const Ring* ring2) {
553  //
554  // calculate RoadSearchCircleSeed
555  //
556  // apply circle seed cuts
557  //
558 
559  // return value
560  bool result = true;
561 
562  // loop over detid's in first rings
563  for ( Ring::const_iterator ring1DetIdIterator = ring1->begin();
564  ring1DetIdIterator != ring1->end();
565  ++ring1DetIdIterator ) {
566 
567  DetId ring1DetId = ring1DetIdIterator->second;
568  std::vector<TrackingRecHit*> ring1RecHits = innerSeedHitVector_.getHitVector(&ring1DetId);
569 
570  // loop over inner rechits
571  for (std::vector<TrackingRecHit*>::const_iterator ring1RecHit = ring1RecHits.begin();
572  ring1RecHit != ring1RecHits.end();
573  ++ring1RecHit) {
574 
575  GlobalPoint ring1GlobalPoint = tracker_->idToDet((*ring1RecHit)->geographicalId())->surface().toGlobal((*ring1RecHit)->localPosition());
576 
577  // calculate phi range around inner hit
578  double innerphi = ring1GlobalPoint.phi();
579  double upperPhiRangeBorder = innerphi + phiRangeDetIdLookup_;
580  double lowerPhiRangeBorder = innerphi - phiRangeDetIdLookup_;
581  if (upperPhiRangeBorder>Geom::pi()) upperPhiRangeBorder -= Geom::twoPi();
582  if (lowerPhiRangeBorder<(-Geom::pi())) lowerPhiRangeBorder += Geom::twoPi();
583 
584  // retrieve vectors of TrackingRecHits in ring2 in phi range
585  std::vector<TrackingRecHit*> ring2RecHits;
586 
587  if (lowerPhiRangeBorder <= upperPhiRangeBorder ) {
588  for ( Ring::const_iterator outerRingDetId = ring2->lower_bound(lowerPhiRangeBorder);
589  outerRingDetId != ring2->upper_bound(upperPhiRangeBorder);
590  ++outerRingDetId) {
591  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
592  ring2RecHits.insert(ring2RecHits.end(),
593  rings.begin(),
594  rings.end());
595  }
596  } else {
597  for ( Ring::const_iterator outerRingDetId = ring2->begin();
598  outerRingDetId != ring2->upper_bound(upperPhiRangeBorder);
599  ++outerRingDetId) {
600  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
601  ring2RecHits.insert(ring2RecHits.end(),
602  rings.begin(),
603  rings.end());
604  }
605  for ( Ring::const_iterator outerRingDetId = ring2->lower_bound(lowerPhiRangeBorder);
606  outerRingDetId != ring2->end();
607  ++outerRingDetId) {
608  std::vector<TrackingRecHit*> rings = outerSeedHitVector_.getHitVector(&(outerRingDetId->second));
609  ring2RecHits.insert(ring2RecHits.end(),
610  rings.begin(),
611  rings.end());
612  }
613  }
614 
615  if ( ring2RecHits.size() > 0 ) {
616  calculateCircleSeedsFromHits(circleSeeds, seed, set, ring1GlobalPoint, *ring1RecHit, ring2RecHits);
617  }
618 
619  }
620  }
621 
622  return result;
623 
624 }
625 
626 bool RoadSearchSeedFinderAlgorithm::calculateCircleSeedsFromHits(std::vector<RoadSearchCircleSeed> &circleSeeds,
627  const Roads::RoadSeed *seed,
628  const Roads::RoadSet *set,
629  GlobalPoint ring1GlobalPoint,
630  TrackingRecHit *ring1RecHit,
631  std::vector<TrackingRecHit*> ring2RecHits,
632  std::vector<TrackingRecHit*> ring3RecHits) {
633  //
634  // calculate RoadSearchCircleSeed
635  //
636  // apply circle seed cuts
637  //
638 
639  // return value
640  bool result = true;
641 
642  for ( std::vector<TrackingRecHit*>::iterator ring2RecHit = ring2RecHits.begin();
643  ring2RecHit != ring2RecHits.end();
644  ++ring2RecHit) {
645  GlobalPoint ring2GlobalPoint = tracker_->idToDet((*ring2RecHit)->geographicalId())->surface().toGlobal((*ring2RecHit)->localPosition());
646  for ( std::vector<TrackingRecHit*>::iterator ring3RecHit = ring3RecHits.begin();
647  ring3RecHit != ring3RecHits.end();
648  ++ring3RecHit) {
649  GlobalPoint ring3GlobalPoint = tracker_->idToDet((*ring3RecHit)->geographicalId())->surface().toGlobal((*ring3RecHit)->localPosition());
650 
651  RoadSearchCircleSeed circle(ring1RecHit,
652  *ring2RecHit,
653  *ring3RecHit,
654  ring1GlobalPoint,
655  ring2GlobalPoint,
656  ring3GlobalPoint);
657 
658  bool addCircle = false;
659  if ( circle.Type() == RoadSearchCircleSeed::straightLine ) {
660  addCircle = true;
661  } else {
662  if ( (circle.Radius() > minRadius_) &&
663  ((circle.InBarrel() &&
665  (!circle.InBarrel() &&
667  addCircle = true;
668 
669  // check if circle compatible with previous circles, if not, add
670  for (std::vector<RoadSearchCircleSeed>::iterator alreadyContainedCircle = circleSeeds.begin(),
671  alreadyContainedCircleEnd = circleSeeds.end();
672  alreadyContainedCircle != alreadyContainedCircleEnd;
673  ++alreadyContainedCircle ) {
674  if ( circle.Compare(&*alreadyContainedCircle,
678  addCircle = false;
679  break;
680  }
681  }
682  }
683  }
684 
685  if ( addCircle ) {
686  circle.setSeed(seed);
687  circle.setSet(set);
688  circleSeeds.push_back(circle);
689  }
690  }
691  }
692 
693  return result;
694 }
695 
696 bool RoadSearchSeedFinderAlgorithm::calculateCircleSeedsFromHits(std::vector<RoadSearchCircleSeed> &circleSeeds,
697  const Roads::RoadSeed *seed,
698  const Roads::RoadSet *set,
699  GlobalPoint ring1GlobalPoint,
700  TrackingRecHit *ring1RecHit,
701  std::vector<TrackingRecHit*> ring2RecHits) {
702  //
703  // calculate RoadSearchCircleSeed from two hits, calculate straight line
704  //
705  //
706 
707  // return value
708  bool result = true;
709 
710  for ( std::vector<TrackingRecHit*>::iterator ring2RecHit = ring2RecHits.begin();
711  ring2RecHit != ring2RecHits.end();
712  ++ring2RecHit) {
713  GlobalPoint ring2GlobalPoint = tracker_->idToDet((*ring2RecHit)->geographicalId())->surface().toGlobal((*ring2RecHit)->localPosition());
714 
715  RoadSearchCircleSeed circle(ring1RecHit,
716  *ring2RecHit,
717  ring1GlobalPoint,
718  ring2GlobalPoint);
719  circle.setSeed(seed);
720  circle.setSet(set);
721  circleSeeds.push_back(circle);
722  }
723 
724  return result;
725 }
726 
728  //
729  // check whether two input rings are on the same layer
730  //
731 
732  // return value
733  bool result = false;
734 
735  // get first DetId of ring
736  const DetId ring1DetId = ring1->getFirst();
737  const DetId ring2DetId = ring2->getFirst();
738 
739  result = detIdsOnSameLayer(ring1DetId,ring2DetId);
740 
741  return result;
742 }
743 
745  //
746  // check whether two detids are on the same layer
747  //
748 
749  // return value
750  bool result = false;
751 
752  // check if both rings belong to same subdetector
753  if ( (unsigned int)id1.subdetId() == StripSubdetector::TIB &&
754  (unsigned int)id2.subdetId() == StripSubdetector::TIB ) {
755  // make TIBDetId instance
756  TIBDetId id1TIB(id1.rawId());
757  TIBDetId id2TIB(id2.rawId());
758  // check whether both rings are on the same TIB layer
759  if ( id1TIB.layer() == id2TIB.layer() ) {
760  result = true;
761  }
762  } else if ( (unsigned int)id1.subdetId() == StripSubdetector::TOB &&
763  (unsigned int)id2.subdetId() == StripSubdetector::TOB ) {
764  // make TOBDetId instance
765  TOBDetId id1TOB(id1.rawId());
766  TOBDetId id2TOB(id2.rawId());
767  // check whether both rings are on the same TOB layer
768  if ( id1TOB.layer() == id2TOB.layer() ) {
769  result = true;
770  }
771  } else if ( (unsigned int)id1.subdetId() == StripSubdetector::TID &&
772  (unsigned int)id2.subdetId() == StripSubdetector::TID) {
773  // make TIDDetId instance
774  TIDDetId id1TID(id1.rawId());
775  TIDDetId id2TID(id2.rawId());
776  // check whether both rings are on the same TID wheel
777  if ( id1TID.wheel() == id2TID.wheel() ) {
778  result = true;
779  }
780  } else if ( (unsigned int)id1.subdetId() == StripSubdetector::TEC &&
781  (unsigned int)id2.subdetId() == StripSubdetector::TEC ) {
782  // make TECDetId instance
783  TECDetId id1TEC(id1.rawId());
784  TECDetId id2TEC(id2.rawId());
785  // check whether both rings are on the same TEC wheel
786  if ( id1TEC.wheel() == id2TEC.wheel() ) {
787  result = true;
788  }
789  } else if ( (unsigned int)id1.subdetId() == PixelSubdetector::PixelBarrel &&
790  (unsigned int)id2.subdetId() == PixelSubdetector::PixelBarrel) {
791  // make PXBDetId instance
792  PXBDetId id1PXB(id1.rawId());
793  PXBDetId id2PXB(id2.rawId());
794  // check whether both rings are on the same PXB layer
795  if ( id1PXB.layer() == id2PXB.layer() ) {
796  result = true;
797  }
798  } else if ( (unsigned int)id1.subdetId() == PixelSubdetector::PixelEndcap &&
799  (unsigned int)id2.subdetId() == PixelSubdetector::PixelEndcap) {
800  // make PXFDetId instance
801  PXFDetId id1PXF(id1.rawId());
802  PXFDetId id2PXF(id2.rawId());
803  // check whether both rings are on the same PXF disk
804  if ( id1PXF.disk() == id2PXF.disk() ) {
805  result = true;
806  }
807  }
808 
809  return result;
810 }
811 
812 
814 
815  const edmNew::DetSetVector<SiStripCluster>& input = *clusters;
816 
817  unsigned int totalClusters = 0;
818 
819  //loop over detectors
820  for (edmNew::DetSetVector<SiStripCluster>::const_iterator DSViter=input.begin(); DSViter!=input.end();DSViter++ ) {
821  totalClusters+=DSViter->size();
822  }
823 
824  return totalClusters;
825 }
T getParameter(std::string const &) const
bool Compare(const RoadSearchCircleSeed *circle, double centerCut, double radiusCut, unsigned int differentHitsCut) const
boost::transform_iterator< IterHelp, const_IdIter > const_iterator
const_iterator begin() const
DetId getFirst() const
Definition: Ring.h:181
unsigned int ClusterCounter(const edmNew::DetSetVector< SiStripCluster > *clusters)
void setCollections(const SiStripRecHit2DCollection *rphiRecHits, const SiStripRecHit2DCollection *stereoRecHits, const SiStripMatchedRecHit2DCollection *matchedRecHits, const SiPixelRecHitCollection *pixelRecHits)
Definition: DetHitAccess.cc:42
const_iterator upper_bound(double phi) const
Definition: Ring.h:224
bool calculateCircleSeedsFromRingsTwoInnerOneOuter(std::vector< RoadSearchCircleSeed > &circleSeeds, const Roads::RoadSeed *seed, const Roads::RoadSet *set, const Ring *ring1, const Ring *ring2, const Ring *ring3)
virtual GlobalVector inTesla(const GlobalPoint &gp) const =0
Field value ad specified global point, in Tesla.
void use_rphiRecHits(bool input)
Definition: DetHitAccess.h:45
GlobalPoint toGlobal(const Local2DPoint &lp) const
Conversion to the global R.F. from the R.F. of the GeomDet.
Definition: GeomDet.h:49
Geom::Phi< T > phi() const
Definition: PV3DBase.h:63
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
const double unitCorrection
#define abs(x)
Definition: mlp_lapack.h:159
void setSeed(const Roads::RoadSeed *input)
void setSet(const Roads::RoadSet *input)
std::vector< RoadSearchSeed > RoadSearchSeedCollection
bool ringsOnSameLayer(const Ring *ring1, const Ring *ring2)
T eta() const
void setSeed(const Roads::RoadSeed *input)
std::vector< std::vector< const Ring * > > RoadSet
Definition: Roads.h:39
uint32_t rawId() const
get the raw id
Definition: DetId.h:45
const_iterator lower_bound(double phi) const
Definition: Ring.h:223
bool calculateCircleSeedsFromHits(std::vector< RoadSearchCircleSeed > &circleSeeds, const Roads::RoadSeed *seed, const Roads::RoadSet *set, GlobalPoint ring1GlobalPoint, TrackingRecHit *ring1RecHit, std::vector< TrackingRecHit * > ring2RecHits, std::vector< TrackingRecHit * > ring3RecHits)
const_iterator begin() const
Definition: Ring.h:147
DetHitAccess::accessMode innerSeedHitAccessMode_
Definition: DDAxes.h:10
Definition: Ring.h:31
bool detIdsOnSameLayer(DetId id1, DetId id2)
bool check(const DataFrame &df, bool capcheck, bool dvercheck)
T z() const
Definition: PV3DBase.h:58
tuple result
Definition: query.py:137
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
iterator begin()
Definition: Roads.h:58
double ImpactParameter() const
void addCircle(double eta, double phi, double radius, const unsigned int nLineSegments, TEveElement *comp, FWProxyBuilderBase *pb)
const_iterator end() const
void run(const SiStripRecHit2DCollection *rphiRecHits, const SiStripRecHit2DCollection *stereoRecHits, const SiStripMatchedRecHit2DCollection *matchedRecHits, const SiPixelRecHitCollection *pixelRecHits, const edm::EventSetup &es, RoadSearchSeedCollection &output)
std::vector< TrackingRecHit * > getHitVector(const DetId *detid)
Definition: DetHitAccess.cc:55
int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:39
virtual const GeomDet * idToDet(DetId) const
tuple conf
Definition: dbtoconf.py:185
tuple input
Definition: collect_tpl.py:10
std::pair< std::vector< const Ring * >, std::vector< const Ring * > > RoadSeed
Definition: Roads.h:38
void use_stereoRecHits(bool input)
Definition: DetHitAccess.h:46
Definition: DetId.h:20
RoadMap::const_iterator const_iterator
Definition: Roads.h:43
Log< T >::type log(const T &t)
Definition: Log.h:22
void setSet(const Roads::RoadSet *input)
RoadSearchSeedFinderAlgorithm(const edm::ParameterSet &conf)
void setMode(accessMode input)
Definition: DetHitAccess.h:44
const T & get() const
Definition: EventSetup.h:55
bool calculateCircleSeedsFromRingsOneInnerOneOuter(std::vector< RoadSearchCircleSeed > &circleSeeds, const Roads::RoadSeed *seed, const Roads::RoadSet *set, const Ring *ring1, const Ring *ring2)
T const * product() const
Definition: ESHandle.h:62
void addHit(const TrackingRecHit *input)
const_iterator end() const
Definition: Ring.h:148
std::vector< std::vector< double > > tmp
Definition: MVATrainer.cc:100
size_type size() const
double pi()
Definition: Pi.h:31
DetHitAccess::accessMode outerSeedHitAccessMode_
double twoPi()
Definition: Pi.h:32
std::vector< unsigned int > usedSeedRingCombinations_
DetIdMap::const_iterator const_iterator
Definition: Ring.h:37
iterator end()
Definition: Roads.h:59
bool calculateCircleSeedsFromRingsOneInnerTwoOuter(std::vector< RoadSearchCircleSeed > &circleSeeds, const Roads::RoadSeed *seed, const Roads::RoadSet *set, const Ring *ring1, const Ring *ring2, const Ring *ring3)
const double speedOfLight
TransientTrackingRecHit::RecHitPointer build(const TrackingRecHit *p) const
build a tracking rechit from an existing rechit