CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
List of all members | Public Types | Public Member Functions | Public Attributes | Private Member Functions | Private Attributes
MuonSeedBuilder Class Reference

#include <MuonSeedBuilder.h>

Public Types

typedef std::deque< bool > BoolContainer
 
typedef
MuonTransientTrackingRecHit::MuonRecHitContainer 		SegmentContainer
 

Public Member Functions

int build (edm::Event &event, const edm::EventSetup &eventSetup, TrajectorySeedCollection &seeds)
 Build seed collection. More...
 
 MuonSeedBuilder (const edm::ParameterSet &, edm::ConsumesCollector &)
 Constructor. More...
 
void setBField (const MagneticField *theField)
 Cache pointer to Magnetic field. More...
 
void setGeometry (const MuonDetLayerGeometry *lgeom)
 Cache pointer to geometry. More...
 
 ~MuonSeedBuilder ()
 Destructor. More...
 

Public Attributes

std::vector< int > badSeedLayer
 

Private Member Functions

double etaError (const GlobalPoint gp, double rErr)
 calculate the eta error from global R error More...
 
bool foundMatchingSegment (int type, SegmentContainer &protoTrack, SegmentContainer &segments, BoolContainer &usedSeg, float &eta_temp, float &phi_temp, int &lastLayer, bool &showeringBefore)
 Find segment which matches protoTrack for endcap only. More...
 
bool IdentifyShowering (SegmentContainer &segs, BoolContainer &usedSeg, float &eta_last, float &phi_last, int layer, int &NShoweringSegments)
 identify the showering layer More...
 
std::vector< TrajectorySeed > seedCleaner (const edm::EventSetup &eventSetup, std::vector< TrajectorySeed > &seeds)
 cleaning the seeds More...
 

Private Attributes

const MagneticField * BField
 
bool debug
 group the seeds More...
 
bool enableCSCMeasurement
 
bool enableDTMeasurement
 
float maxDeltaEtaCSC
 
float maxDeltaEtaDT
 
float maxDeltaEtaOverlap
 
float maxDeltaPhiCSC
 
float maxDeltaPhiDT
 
float maxDeltaPhiOverlap
 
float maxEtaResolutionCSC
 
float maxEtaResolutionDT
 
float maxPhiResolutionCSC
 
float maxPhiResolutionDT
 
int minCSCHitsPerSegment
 
int minDTHitsPerSegment
 
const MuonDetLayerGeometry * muonLayers
 
MuonDetLayerMeasurements * muonMeasurements
 
MuonSeedCleaner * muonSeedClean_
 
MuonSeedCreator * muonSeedCreate_
 Create seed according to region (CSC, DT, Overlap) More...
 
int NShowerSeg
 
std::vector< int > ShoweringLayers
 
SegmentContainer ShoweringSegments
 
edm::InputTag theCSCSegmentLabel
 Name of the CSC segment collection. More...
 
edm::InputTag theDTSegmentLabel
 Name of the DT segment collection. More...
 
float theMinMomentum
 

Detailed Description

Algorith to build TrajectorySeed for muon standalone reconstruction. The segments are sorted out to make a protoTrack (vector of matching segments in different stations a.k.a. layers), for DT+overlap and CSC regions, in that order. The protoTrack is then passed to the seed creator to create CSC, overlap and/or DT seeds.

Author
Shih-Chuan Kao, Dominique Fortin - UCR

Definition at line 30 of file MuonSeedBuilder.h.

Member Typedef Documentation

typedef std::deque<bool> MuonSeedBuilder::BoolContainer

Definition at line 33 of file MuonSeedBuilder.h.

typedef MuonTransientTrackingRecHit::MuonRecHitContainer MuonSeedBuilder::SegmentContainer

Definition at line 32 of file MuonSeedBuilder.h.

Constructor & Destructor Documentation

MuonSeedBuilder::MuonSeedBuilder ( const edm::ParameterSet &  pset,
edm::ConsumesCollector &  iC 
)
explicit

Constructor.

See header file for a description of this class.

Author
Shih-Chuan Kao, Dominique Fortin - UCR

Definition at line 51 of file MuonSeedBuilder.cc.

References debug, enableCSCMeasurement, enableDTMeasurement, edm::ParameterSet::getParameter(), maxDeltaEtaCSC, maxDeltaEtaDT, maxDeltaEtaOverlap, maxDeltaPhiCSC, maxDeltaPhiDT, maxDeltaPhiOverlap, maxEtaResolutionCSC, maxEtaResolutionDT, maxPhiResolutionCSC, maxPhiResolutionDT, minCSCHitsPerSegment, minDTHitsPerSegment, muonMeasurements, muonSeedClean_, muonSeedCreate_, theCSCSegmentLabel, and theDTSegmentLabel.

51  {
52  // Local Debug flag
53  debug = pset.getParameter<bool>("DebugMuonSeed");
54 
55  // enable the DT chamber
56  enableDTMeasurement = pset.getParameter<bool>("EnableDTMeasurement");
57  theDTSegmentLabel = pset.getParameter<edm::InputTag>("DTSegmentLabel");
58 
59  // enable the CSC chamber
60  enableCSCMeasurement = pset.getParameter<bool>("EnableCSCMeasurement");
61  theCSCSegmentLabel = pset.getParameter<edm::InputTag>("CSCSegmentLabel");
62 
63  // Parameters for seed creation in endcap region
64  minCSCHitsPerSegment = pset.getParameter<int>("minCSCHitsPerSegment");
65  maxDeltaEtaCSC = pset.getParameter<double>("maxDeltaEtaCSC");
66  maxDeltaPhiCSC = pset.getParameter<double>("maxDeltaPhiCSC");
67 
68  // Parameters for seed creation in overlap region
69  maxDeltaEtaOverlap = pset.getParameter<double>("maxDeltaEtaOverlap");
70  maxDeltaPhiOverlap = pset.getParameter<double>("maxDeltaPhiOverlap");
71 
72  // Parameters for seed creation in barrel region
73  minDTHitsPerSegment = pset.getParameter<int>("minDTHitsPerSegment");
74  maxDeltaEtaDT = pset.getParameter<double>("maxDeltaEtaDT");
75  maxDeltaPhiDT = pset.getParameter<double>("maxDeltaPhiDT");
76 
77  // Parameters to suppress combinatorics (ghosts)
78  maxEtaResolutionDT = pset.getParameter<double>("maxEtaResolutionDT");
79  maxPhiResolutionDT = pset.getParameter<double>("maxPhiResolutionDT");
80  maxEtaResolutionCSC = pset.getParameter<double>("maxEtaResolutionCSC");
81  maxPhiResolutionCSC = pset.getParameter<double>("maxPhiResolutionCSC");
82 
83  // Class for forming muon seeds
84  muonSeedCreate_ = new MuonSeedCreator(pset);
85  muonSeedClean_ = new MuonSeedCleaner(pset, edm::ConsumesCollector(iC));
86 
87  // Instantiate the accessor (get the segments: DT + CSC but not RPC=false)
88  muonMeasurements = new MuonDetLayerMeasurements(theDTSegmentLabel,
89  theCSCSegmentLabel,
90  edm::InputTag(),
91  edm::InputTag(),
92  edm::InputTag(),
93  iC,
94  enableDTMeasurement,
95  enableCSCMeasurement,
96  false,
97  false,
98  false);
99 }
MuonSeedBuilder::debug
bool debug
group the seeds
Definition: MuonSeedBuilder.h:106
MuonSeedBuilder::muonMeasurements
MuonDetLayerMeasurements * muonMeasurements
Definition: MuonSeedBuilder.h:156
MuonSeedBuilder::muonSeedClean_
MuonSeedCleaner * muonSeedClean_
Definition: MuonSeedBuilder.h:140
MuonSeedBuilder::theCSCSegmentLabel
edm::InputTag theCSCSegmentLabel
Name of the CSC segment collection.
Definition: MuonSeedBuilder.h:136
MuonSeedBuilder::theDTSegmentLabel
edm::InputTag theDTSegmentLabel
Name of the DT segment collection.
Definition: MuonSeedBuilder.h:133
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
MuonSeedBuilder::muonSeedCreate_
MuonSeedCreator * muonSeedCreate_
Create seed according to region (CSC, DT, Overlap)
Definition: MuonSeedBuilder.h:139
MuonSeedBuilder::~MuonSeedBuilder ( )

Destructor.

Definition at line 104 of file MuonSeedBuilder.cc.

References muonMeasurements, muonSeedClean_, and muonSeedCreate_.

104  {
105  delete muonSeedCreate_;
106  delete muonSeedClean_;
107  if (muonMeasurements)
108  delete muonMeasurements;
109 }
MuonSeedBuilder::muonMeasurements
MuonDetLayerMeasurements * muonMeasurements
Definition: MuonSeedBuilder.h:156
MuonSeedBuilder::muonSeedClean_
MuonSeedCleaner * muonSeedClean_
Definition: MuonSeedBuilder.h:140
MuonSeedBuilder::muonSeedCreate_
MuonSeedCreator * muonSeedCreate_
Create seed according to region (CSC, DT, Overlap)
Definition: MuonSeedBuilder.h:139

Member Function Documentation

int MuonSeedBuilder::build ( edm::Event &  event,
const edm::EventSetup &  eventSetup,
TrajectorySeedCollection &  seeds 
)

Build seed collection.

Definition at line 119 of file MuonSeedBuilder.cc.

References MuonDetLayerGeometry::allDTLayers(), MuonDetLayerGeometry::backwardCSCLayers(), BField, gather_cfg::cout, MuonSeedCreator::createSeed(), debug, PV3DBase< T, PVType, FrameType >::eta(), MuonDetLayerGeometry::forwardCSCLayers(), foundMatchingSegment(), runTauDisplay::gp, mps_fire::i, IdentifyShowering(), LayerTriplets::layers(), minCSCHitsPerSegment, minDTHitsPerSegment, muonLayers, muonMeasurements, muonSeedClean_, muonSeedCreate_, NShowerSeg, PV3DBase< T, PVType, FrameType >::phi(), MuonDetLayerMeasurements::recHits(), MuonSeedCleaner::seedCleaner(), MuonSeedCreator::setBField(), ShoweringLayers, and ShoweringSegments.

Referenced by MuonSeedProducer::produce().

119  {
120  // Pass the Magnetic Field to where the seed is create
121  muonSeedCreate_->setBField(BField);
122 
123  // Create temporary collection of seeds which will be cleaned up to remove combinatorics
124  std::vector<TrajectorySeed> rawSeeds;
125  std::vector<float> etaOfSeed;
126  std::vector<float> phiOfSeed;
127  std::vector<int> nSegOnSeed;
128 
129  // Instantiate the accessor (get the segments: DT + CSC but not RPC=false)
130  // MuonDetLayerMeasurements muonMeasurements(enableDTMeasurement,enableCSCMeasurement,false,
131  // theDTSegmentLabel.label(),theCSCSegmentLabel.label());
132 
133  // 1) Get the various stations and store segments in containers for each station (layers)
134 
135  // 1a. get the DT segments by stations (layers):
136  std::vector<const DetLayer*> dtLayers = muonLayers->allDTLayers();
137 
138  SegmentContainer DTlist4 = muonMeasurements->recHits(dtLayers[3], event);
139  SegmentContainer DTlist3 = muonMeasurements->recHits(dtLayers[2], event);
140  SegmentContainer DTlist2 = muonMeasurements->recHits(dtLayers[1], event);
141  SegmentContainer DTlist1 = muonMeasurements->recHits(dtLayers[0], event);
142 
143  // Initialize flags that a given segment has been allocated to a seed
144  BoolContainer usedDTlist4(DTlist4.size(), false);
145  BoolContainer usedDTlist3(DTlist3.size(), false);
146  BoolContainer usedDTlist2(DTlist2.size(), false);
147  BoolContainer usedDTlist1(DTlist1.size(), false);
148 
149  if (debug) {
150  std::cout << "*** Number of DT segments is: " << DTlist4.size() + DTlist3.size() + DTlist2.size() + DTlist1.size()
151  << std::endl;
152  std::cout << "In MB1: " << DTlist1.size() << std::endl;
153  std::cout << "In MB2: " << DTlist2.size() << std::endl;
154  std::cout << "In MB3: " << DTlist3.size() << std::endl;
155  std::cout << "In MB4: " << DTlist4.size() << std::endl;
156  }
157 
158  // 1b. get the CSC segments by stations (layers):
159  // 1b.1 Global z < 0
160  std::vector<const DetLayer*> cscBackwardLayers = muonLayers->backwardCSCLayers();
161  SegmentContainer CSClist4B = muonMeasurements->recHits(cscBackwardLayers[4], event);
162  SegmentContainer CSClist3B = muonMeasurements->recHits(cscBackwardLayers[3], event);
163  SegmentContainer CSClist2B = muonMeasurements->recHits(cscBackwardLayers[2], event);
164  SegmentContainer CSClist1B = muonMeasurements->recHits(cscBackwardLayers[1], event); // ME1/2 and 1/3
165  SegmentContainer CSClist0B = muonMeasurements->recHits(cscBackwardLayers[0], event); // ME11
166 
167  BoolContainer usedCSClist4B(CSClist4B.size(), false);
168  BoolContainer usedCSClist3B(CSClist3B.size(), false);
169  BoolContainer usedCSClist2B(CSClist2B.size(), false);
170  BoolContainer usedCSClist1B(CSClist1B.size(), false);
171  BoolContainer usedCSClist0B(CSClist0B.size(), false);
172 
173  // 1b.2 Global z > 0
174  std::vector<const DetLayer*> cscForwardLayers = muonLayers->forwardCSCLayers();
175  SegmentContainer CSClist4F = muonMeasurements->recHits(cscForwardLayers[4], event);
176  SegmentContainer CSClist3F = muonMeasurements->recHits(cscForwardLayers[3], event);
177  SegmentContainer CSClist2F = muonMeasurements->recHits(cscForwardLayers[2], event);
178  SegmentContainer CSClist1F = muonMeasurements->recHits(cscForwardLayers[1], event);
179  SegmentContainer CSClist0F = muonMeasurements->recHits(cscForwardLayers[0], event);
180 
181  BoolContainer usedCSClist4F(CSClist4F.size(), false);
182  BoolContainer usedCSClist3F(CSClist3F.size(), false);
183  BoolContainer usedCSClist2F(CSClist2F.size(), false);
184  BoolContainer usedCSClist1F(CSClist1F.size(), false);
185  BoolContainer usedCSClist0F(CSClist0F.size(), false);
186 
187  if (debug) {
188  std::cout << "*** Number of CSC segments is "
189  << CSClist4F.size() + CSClist3F.size() + CSClist2F.size() + CSClist1F.size() + CSClist0F.size() +
190  CSClist4B.size() + CSClist3B.size() + CSClist2B.size() + CSClist1B.size() + CSClist0B.size()
191  << std::endl;
192  std::cout << "In ME11: " << CSClist0F.size() + CSClist0B.size() << std::endl;
193  std::cout << "In ME12: " << CSClist1F.size() + CSClist1B.size() << std::endl;
194  std::cout << "In ME2 : " << CSClist2F.size() + CSClist2B.size() << std::endl;
195  std::cout << "In ME3 : " << CSClist3F.size() + CSClist3B.size() << std::endl;
196  std::cout << "In ME4 : " << CSClist4F.size() + CSClist4B.size() << std::endl;
197  }
198 
199  /* ******************************************************************************************************************
200  * Form seeds in barrel region
201  *
202  * Proceed from inside -> out
203  * ******************************************************************************************************************/
204 
205  // Loop over all possible MB1 segment to form seeds:
206  int index = -1;
207  for (SegmentContainer::iterator it = DTlist1.begin(); it != DTlist1.end(); ++it) {
208  index++;
209 
210  if (usedDTlist1[index] == true)
211  continue;
212  if (int((*it)->recHits().size()) < minDTHitsPerSegment)
213  continue;
214  if ((*it)->dimension() != 4)
215  continue;
216 
217  //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
218  //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
219 
220  // Global position of starting point for protoTrack
221  GlobalPoint gp = (*it)->globalPosition();
222  float eta_temp = gp.eta();
223  float phi_temp = gp.phi();
224  bool showeringBefore = false;
225  NShowerSeg = 0;
226  if (IdentifyShowering(DTlist1, usedDTlist1, eta_temp, phi_temp, -1, NShowerSeg))
227  showeringBefore = true;
228  int NShowers = 0;
229  if (showeringBefore) {
230  //usedDTlist1[index] = true;
231  NShowers++;
232  }
233 
234  SegmentContainer protoTrack;
235  protoTrack.push_back(*it);
236 
237  std::vector<int> layers;
238  layers.push_back(-1);
239 
240  // Try adding segment from other stations
241  if (foundMatchingSegment(
242  3, protoTrack, DTlist2, usedDTlist2, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
243  layers.push_back(-2);
244  if (showeringBefore)
245  NShowers++;
246  if (foundMatchingSegment(
247  3, protoTrack, DTlist3, usedDTlist3, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
248  layers.push_back(-3);
249  if (showeringBefore)
250  NShowers++;
251  if (foundMatchingSegment(
252  3, protoTrack, DTlist4, usedDTlist4, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
253  layers.push_back(-4);
254  if (showeringBefore)
255  NShowers++;
256 
257  // Check if in overlap region
258  if (eta_temp > 0.8) {
259  if (foundMatchingSegment(
260  2, protoTrack, CSClist1F, usedCSClist1F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
261  layers.push_back(1);
262  if (showeringBefore)
263  NShowers++;
264  if (foundMatchingSegment(
265  2, protoTrack, CSClist2F, usedCSClist2F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
266  layers.push_back(2);
267  if (showeringBefore)
268  NShowers++;
269  if (foundMatchingSegment(
270  2, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
271  layers.push_back(3);
272  if (showeringBefore)
273  NShowers++;
274  } else if (eta_temp < -0.8) {
275  if (foundMatchingSegment(
276  2, protoTrack, CSClist1B, usedCSClist1B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
277  layers.push_back(1);
278  if (showeringBefore)
279  NShowers++;
280  if (foundMatchingSegment(
281  2, protoTrack, CSClist2B, usedCSClist2B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
282  layers.push_back(2);
283  if (showeringBefore)
284  NShowers++;
285  if (foundMatchingSegment(
286  2, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
287  layers.push_back(3);
288  if (showeringBefore)
289  NShowers++;
290  }
291 
292  // adding showering information
293  if (layers.size() < 2 && !ShoweringSegments.empty()) {
294  for (size_t i = 0; i < ShoweringSegments.size(); i++) {
295  if (ShoweringLayers[i] > 0) {
296  if (ShoweringLayers[i] <= layers[layers.size() - 1])
297  continue;
298  protoTrack.push_back(ShoweringSegments[i]);
299  layers.push_back(ShoweringLayers[i]);
300  }
301  if (ShoweringLayers[i] < 0 && layers[layers.size() - 1] < 0) {
302  if (ShoweringLayers[i] >= layers[layers.size() - 1])
303  continue;
304  protoTrack.push_back(ShoweringSegments[i]);
305  layers.push_back(ShoweringLayers[i]);
306  }
307  }
308  }
309  ShoweringSegments.clear();
310  ShoweringLayers.clear();
311 
312  TrajectorySeed thisSeed;
313 
314  if (layers.size() < 2) {
315  thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
316  } else {
317  if (layers[layers.size() - 1] > 0) {
318  thisSeed = muonSeedCreate_->createSeed(2, protoTrack, layers, NShowers, NShowerSeg);
319  } else {
320  thisSeed = muonSeedCreate_->createSeed(3, protoTrack, layers, NShowers, NShowerSeg);
321  }
322  }
323  // Add the seeds to master collection
324  rawSeeds.push_back(thisSeed);
325  etaOfSeed.push_back(eta_temp);
326  phiOfSeed.push_back(phi_temp);
327  nSegOnSeed.push_back(protoTrack.size());
328 
329  // Marked segment as used
330  usedDTlist1[index] = true;
331  }
332 
333  // Loop over all possible MB2 segment to form seeds:
334  index = -1;
335  for (SegmentContainer::iterator it = DTlist2.begin(); it != DTlist2.end(); ++it) {
336  index++;
337 
338  if (usedDTlist2[index] == true)
339  continue;
340  if (int((*it)->recHits().size()) < minDTHitsPerSegment)
341  continue;
342  if ((*it)->dimension() != 4)
343  continue;
344 
345  //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
346  //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
347 
348  // Global position of starting point for protoTrack
349  GlobalPoint gp = (*it)->globalPosition();
350  float eta_temp = gp.eta();
351  float phi_temp = gp.phi();
352  bool showeringBefore = false;
353  NShowerSeg = 0;
354  if (IdentifyShowering(DTlist2, usedDTlist2, eta_temp, phi_temp, -2, NShowerSeg))
355  showeringBefore = true;
356  int NShowers = 0;
357  if (showeringBefore) {
358  // usedDTlist2[index] = true;
359  NShowers++;
360  }
361 
362  SegmentContainer protoTrack;
363  protoTrack.push_back(*it);
364 
365  std::vector<int> layers;
366  layers.push_back(-2);
367 
368  // Try adding segment from other stations
369  if (foundMatchingSegment(
370  3, protoTrack, DTlist3, usedDTlist3, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
371  layers.push_back(-3);
372  if (showeringBefore)
373  NShowers++;
374  if (foundMatchingSegment(
375  3, protoTrack, DTlist4, usedDTlist4, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
376  layers.push_back(-4);
377  if (showeringBefore)
378  NShowers++;
379 
380  // Check if in overlap region
381  if (eta_temp > 0.8) {
382  if (foundMatchingSegment(
383  2, protoTrack, CSClist1F, usedCSClist1F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
384  layers.push_back(1);
385  if (showeringBefore)
386  NShowers++;
387  if (foundMatchingSegment(
388  2, protoTrack, CSClist2F, usedCSClist2F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
389  layers.push_back(2);
390  if (showeringBefore)
391  NShowers++;
392  if (foundMatchingSegment(
393  2, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
394  layers.push_back(3);
395  if (showeringBefore)
396  NShowers++;
397  } else if (eta_temp < -0.8) {
398  if (foundMatchingSegment(
399  2, protoTrack, CSClist1B, usedCSClist1B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
400  layers.push_back(1);
401  if (showeringBefore)
402  NShowers++;
403  if (foundMatchingSegment(
404  2, protoTrack, CSClist2B, usedCSClist2B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
405  layers.push_back(2);
406  if (showeringBefore)
407  NShowers++;
408  if (foundMatchingSegment(
409  2, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
410  layers.push_back(3);
411  if (showeringBefore)
412  NShowers++;
413  }
414 
415  // adding showering information
416  if (layers.size() < 2 && !ShoweringSegments.empty()) {
417  for (size_t i = 0; i < ShoweringSegments.size(); i++) {
418  if (ShoweringLayers[i] > 0) {
419  if (ShoweringLayers[i] <= layers[layers.size() - 1])
420  continue;
421  protoTrack.push_back(ShoweringSegments[i]);
422  layers.push_back(ShoweringLayers[i]);
423  }
424  if (ShoweringLayers[i] < 0 && layers[layers.size() - 1] < 0) {
425  if (ShoweringLayers[i] >= layers[layers.size() - 1])
426  continue;
427  protoTrack.push_back(ShoweringSegments[i]);
428  layers.push_back(ShoweringLayers[i]);
429  }
430  }
431  }
432  ShoweringSegments.clear();
433  ShoweringLayers.clear();
434 
435  TrajectorySeed thisSeed;
436 
437  if (layers.size() < 2) {
438  thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
439  } else {
440  if (layers[layers.size() - 1] > 0) {
441  thisSeed = muonSeedCreate_->createSeed(2, protoTrack, layers, NShowers, NShowerSeg);
442  } else {
443  thisSeed = muonSeedCreate_->createSeed(3, protoTrack, layers, NShowers, NShowerSeg);
444  }
445  }
446  // Add the seeds to master collection
447  rawSeeds.push_back(thisSeed);
448  etaOfSeed.push_back(eta_temp);
449  phiOfSeed.push_back(phi_temp);
450  nSegOnSeed.push_back(protoTrack.size());
451 
452  // Marked segment as used
453  usedDTlist2[index] = true;
454  }
455 
456  // Loop over all possible MB3 segment to form seeds:
457  index = -1;
458  for (SegmentContainer::iterator it = DTlist3.begin(); it != DTlist3.end(); ++it) {
459  index++;
460 
461  if (usedDTlist3[index] == true)
462  continue;
463  if (int((*it)->recHits().size()) < minDTHitsPerSegment)
464  continue;
465  if ((*it)->dimension() != 4)
466  continue;
467 
468  //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
469  //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
470 
471  // Global position of starting point for protoTrack
472  GlobalPoint gp = (*it)->globalPosition();
473  float eta_temp = gp.eta();
474  float phi_temp = gp.phi();
475  bool showeringBefore = false;
476  NShowerSeg = 0;
477  if (IdentifyShowering(DTlist3, usedDTlist3, eta_temp, phi_temp, -3, NShowerSeg))
478  showeringBefore = true;
479  int NShowers = 0;
480  if (showeringBefore) {
481  // usedDTlist3[index] = true;
482  NShowers++;
483  }
484 
485  SegmentContainer protoTrack;
486  protoTrack.push_back(*it);
487 
488  std::vector<int> layers;
489  layers.push_back(-3);
490 
491  // Try adding segment from other stations
492  if (foundMatchingSegment(
493  3, protoTrack, DTlist4, usedDTlist4, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
494  layers.push_back(-4);
495  if (showeringBefore)
496  NShowers++;
497 
498  // Check if in overlap region
499  if (eta_temp > 0.8) {
500  if (foundMatchingSegment(
501  2, protoTrack, CSClist1F, usedCSClist1F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
502  layers.push_back(1);
503  if (showeringBefore)
504  NShowers++;
505  if (foundMatchingSegment(
506  2, protoTrack, CSClist2F, usedCSClist2F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
507  layers.push_back(2);
508  if (showeringBefore)
509  NShowers++;
510  if (foundMatchingSegment(
511  2, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
512  layers.push_back(3);
513  if (showeringBefore)
514  NShowers++;
515  } else if (eta_temp < -0.8) {
516  if (foundMatchingSegment(
517  2, protoTrack, CSClist1B, usedCSClist1B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
518  layers.push_back(1);
519  if (showeringBefore)
520  NShowers++;
521  if (foundMatchingSegment(
522  2, protoTrack, CSClist2B, usedCSClist2B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
523  layers.push_back(2);
524  if (showeringBefore)
525  NShowers++;
526  if (foundMatchingSegment(
527  2, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
528  layers.push_back(3);
529  if (showeringBefore)
530  NShowers++;
531  }
532 
533  // adding showering information
534  if (layers.size() < 2 && !ShoweringSegments.empty()) {
535  for (size_t i = 0; i < ShoweringSegments.size(); i++) {
536  if (ShoweringLayers[i] > 0) {
537  if (ShoweringLayers[i] <= layers[layers.size() - 1])
538  continue;
539  protoTrack.push_back(ShoweringSegments[i]);
540  layers.push_back(ShoweringLayers[i]);
541  }
542  if (ShoweringLayers[i] < 0 && layers[layers.size() - 1] < 0) {
543  if (ShoweringLayers[i] >= layers[layers.size() - 1])
544  continue;
545  protoTrack.push_back(ShoweringSegments[i]);
546  layers.push_back(ShoweringLayers[i]);
547  }
548  }
549  }
550  ShoweringSegments.clear();
551  ShoweringLayers.clear();
552 
553  TrajectorySeed thisSeed;
554  if (layers.size() < 2) {
555  thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
556  } else {
557  if (layers[layers.size() - 1] > 0) {
558  thisSeed = muonSeedCreate_->createSeed(2, protoTrack, layers, NShowers, NShowerSeg);
559  } else {
560  thisSeed = muonSeedCreate_->createSeed(3, protoTrack, layers, NShowers, NShowerSeg);
561  }
562  }
563 
564  // Add the seeds to master collection
565  rawSeeds.push_back(thisSeed);
566  etaOfSeed.push_back(eta_temp);
567  phiOfSeed.push_back(phi_temp);
568  nSegOnSeed.push_back(protoTrack.size());
569 
570  // Marked segment as used
571  usedDTlist3[index] = true;
572  }
573 
574  /* *********************************************************************************************************************
575  * Form seeds from backward endcap
576  *
577  * Proceed from inside -> out
578  * *********************************************************************************************************************/
579 
580  // Loop over all possible ME11 segment to form seeds:
581  index = -1;
582 
583  for (SegmentContainer::iterator it = CSClist0B.begin(); it != CSClist0B.end(); ++it) {
584  index++;
585 
586  if (usedCSClist0B[index] == true)
587  continue;
588  if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
589  continue;
590 
591  //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
592  //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
593 
594  // Global position of starting point for protoTrack
595  GlobalPoint gp = (*it)->globalPosition();
596  float eta_temp = gp.eta();
597  float phi_temp = gp.phi();
598  bool showeringBefore = false;
599  NShowerSeg = 0;
600  if (IdentifyShowering(CSClist0B, usedCSClist0B, eta_temp, phi_temp, 0, NShowerSeg))
601  showeringBefore = true;
602  int NShowers = 0;
603  if (showeringBefore) {
604  // usedCSClist0B[index] = true;
605  NShowers++;
606  }
607 
608  SegmentContainer protoTrack;
609  protoTrack.push_back(*it);
610 
611  std::vector<int> layers;
612  layers.push_back(0);
613 
614  // Try adding segment from other station
615  if (foundMatchingSegment(
616  1, protoTrack, CSClist1B, usedCSClist1B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
617  layers.push_back(1);
618  if (showeringBefore)
619  NShowers++;
620  if (foundMatchingSegment(
621  1, protoTrack, CSClist2B, usedCSClist2B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
622  layers.push_back(2);
623  if (showeringBefore)
624  NShowers++;
625  if (foundMatchingSegment(
626  1, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
627  layers.push_back(3);
628  if (showeringBefore)
629  NShowers++;
630  if (foundMatchingSegment(
631  1, protoTrack, CSClist4B, usedCSClist4B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
632  layers.push_back(4);
633  if (showeringBefore)
634  NShowers++;
635 
636  // adding showering information
637  if (layers.size() < 2 && !ShoweringSegments.empty()) {
638  for (size_t i = 0; i < ShoweringSegments.size(); i++) {
639  if (ShoweringLayers[i] <= layers[layers.size() - 1])
640  continue;
641  protoTrack.push_back(ShoweringSegments[i]);
642  layers.push_back(ShoweringLayers[i]);
643  }
644  }
645  ShoweringSegments.clear();
646  ShoweringLayers.clear();
647 
648  TrajectorySeed thisSeed;
649  if (layers.size() < 2) {
650  thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
651  } else {
652  if (fabs(gp.eta()) > 1.7) {
653  thisSeed = muonSeedCreate_->createSeed(5, protoTrack, layers, NShowers, NShowerSeg);
654  } else {
655  thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
656  }
657  }
658 
659  // Add the seeds to master collection
660  rawSeeds.push_back(thisSeed);
661  etaOfSeed.push_back(eta_temp);
662  phiOfSeed.push_back(phi_temp);
663  nSegOnSeed.push_back(protoTrack.size());
664 
665  // mark this segment as used
666  usedCSClist0B[index] = true;
667  }
668 
669  // Loop over all possible ME1/2 ME1/3 segment to form seeds:
670  index = -1;
671  for (SegmentContainer::iterator it = CSClist1B.begin(); it != CSClist1B.end(); ++it) {
672  index++;
673 
674  if (usedCSClist1B[index] == true)
675  continue;
676  if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
677  continue;
678 
679  //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
680  //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
681 
682  // Global position of starting point for protoTrack
683  GlobalPoint gp = (*it)->globalPosition();
684  float eta_temp = gp.eta();
685  float phi_temp = gp.phi();
686  bool showeringBefore = false;
687  NShowerSeg = 0;
688  if (IdentifyShowering(CSClist1B, usedCSClist1B, eta_temp, phi_temp, 1, NShowerSeg))
689  showeringBefore = true;
690  int NShowers = 0;
691  if (showeringBefore) {
692  // usedCSClist1B[index] = true;
693  NShowers++;
694  }
695 
696  SegmentContainer protoTrack;
697  protoTrack.push_back(*it);
698 
699  std::vector<int> layers;
700  layers.push_back(1);
701 
702  // Try adding segment from other stations
703  if (foundMatchingSegment(
704  1, protoTrack, CSClist2B, usedCSClist2B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
705  layers.push_back(2);
706  if (showeringBefore)
707  NShowers++;
708  if (foundMatchingSegment(
709  1, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
710  layers.push_back(3);
711  if (showeringBefore)
712  NShowers++;
713  if (foundMatchingSegment(
714  1, protoTrack, CSClist4B, usedCSClist4B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
715  layers.push_back(4);
716  if (showeringBefore)
717  NShowers++;
718 
719  // adding showering information
720  if (layers.size() < 2 && !ShoweringSegments.empty()) {
721  for (size_t i = 0; i < ShoweringSegments.size(); i++) {
722  if (ShoweringLayers[i] <= layers[layers.size() - 1])
723  continue;
724  protoTrack.push_back(ShoweringSegments[i]);
725  layers.push_back(ShoweringLayers[i]);
726  }
727  }
728  ShoweringSegments.clear();
729  ShoweringLayers.clear();
730 
731  TrajectorySeed thisSeed;
732  if (layers.size() < 2) {
733  thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
734  } else {
735  thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
736  }
737  // Add the seeds to master collection
738  rawSeeds.push_back(thisSeed);
739  etaOfSeed.push_back(eta_temp);
740  phiOfSeed.push_back(phi_temp);
741  nSegOnSeed.push_back(protoTrack.size());
742 
743  // mark this segment as used
744  usedCSClist1B[index] = true;
745  }
746 
747  // Loop over all possible ME2 segment to form seeds:
748  index = -1;
749  for (SegmentContainer::iterator it = CSClist2B.begin(); it != CSClist2B.end(); ++it) {
750  index++;
751 
752  if (usedCSClist2B[index] == true)
753  continue;
754  if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
755  continue;
756 
757  double dof = static_cast<double>((*it)->degreesOfFreedom());
758  if (((*it)->chi2() / dof) > 20000.0)
759  continue;
760 
761  // Global position of starting point for protoTrack
762  GlobalPoint gp = (*it)->globalPosition();
763  float eta_temp = gp.eta();
764  float phi_temp = gp.phi();
765  bool showeringBefore = false;
766  NShowerSeg = 0;
767  if (IdentifyShowering(CSClist2B, usedCSClist2B, eta_temp, phi_temp, 2, NShowerSeg))
768  showeringBefore = true;
769  int NShowers = 0;
770  if (showeringBefore) {
771  // usedCSClist2B[index] = true;
772  NShowers++;
773  }
774 
775  SegmentContainer protoTrack;
776  protoTrack.push_back(*it);
777 
778  std::vector<int> layers;
779  layers.push_back(2);
780 
781  // Try adding segment from other stations
782  if (foundMatchingSegment(
783  1, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
784  layers.push_back(3);
785  if (showeringBefore)
786  NShowers++;
787  if (foundMatchingSegment(
788  1, protoTrack, CSClist4B, usedCSClist4B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
789  layers.push_back(4);
790  if (showeringBefore)
791  NShowers++;
792 
793  // adding showering information
794  if (layers.size() < 2 && !ShoweringSegments.empty()) {
795  for (size_t i = 0; i < ShoweringSegments.size(); i++) {
796  if (ShoweringLayers[i] <= layers[layers.size() - 1])
797  continue;
798  protoTrack.push_back(ShoweringSegments[i]);
799  layers.push_back(ShoweringLayers[i]);
800  }
801  }
802  ShoweringSegments.clear();
803  ShoweringLayers.clear();
804 
805  TrajectorySeed thisSeed;
806  if (layers.size() < 2) {
807  thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
808  } else {
809  thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
810  }
811 
812  // Add the seeds to master collection
813  rawSeeds.push_back(thisSeed);
814  etaOfSeed.push_back(eta_temp);
815  phiOfSeed.push_back(phi_temp);
816  nSegOnSeed.push_back(protoTrack.size());
817  // mark this segment as used
818  usedCSClist2B[index] = true;
819  }
820 
821  // Loop over all possible ME3 segment to form seeds:
822  index = -1;
823  for (SegmentContainer::iterator it = CSClist3B.begin(); it != CSClist3B.end(); ++it) {
824  index++;
825 
826  if (usedCSClist3B[index] == true)
827  continue;
828  if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
829  continue;
830 
831  double dof = static_cast<double>((*it)->degreesOfFreedom());
832  if (((*it)->chi2() / dof) > 20000.0)
833  continue;
834 
835  // Global position of starting point for protoTrack
836  GlobalPoint gp = (*it)->globalPosition();
837  float eta_temp = gp.eta();
838  float phi_temp = gp.phi();
839  bool showeringBefore = false;
840  NShowerSeg = 0;
841  if (IdentifyShowering(CSClist3B, usedCSClist3B, eta_temp, phi_temp, 3, NShowerSeg))
842  showeringBefore = true;
843  int NShowers = 0;
844  if (showeringBefore) {
845  // usedCSClist3B[index] = true;
846  NShowers++;
847  }
848 
849  SegmentContainer protoTrack;
850  protoTrack.push_back(*it);
851 
852  std::vector<int> layers;
853  layers.push_back(2);
854 
855  // Try adding segment from other stations
856  if (foundMatchingSegment(
857  1, protoTrack, CSClist4B, usedCSClist4B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
858  layers.push_back(4);
859  if (showeringBefore)
860  NShowers++;
861 
862  // adding showering information
863  if (layers.size() < 2 && !ShoweringSegments.empty()) {
864  for (size_t i = 0; i < ShoweringSegments.size(); i++) {
865  if (ShoweringLayers[i] <= layers[layers.size() - 1])
866  continue;
867  protoTrack.push_back(ShoweringSegments[i]);
868  layers.push_back(ShoweringLayers[i]);
869  }
870  }
871  ShoweringSegments.clear();
872  ShoweringLayers.clear();
873 
874  // mark this segment as used
875  usedCSClist3B[index] = true;
876 
877  if (layers.size() < 2)
878  continue;
879  TrajectorySeed thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
880 
881  // Add the seeds to master collection
882  rawSeeds.push_back(thisSeed);
883  etaOfSeed.push_back(eta_temp);
884  phiOfSeed.push_back(phi_temp);
885  nSegOnSeed.push_back(protoTrack.size());
886  }
887 
888  /* *****************************************************************************************************************
889  * Form seeds from forward endcap
890  *
891  * Proceed from inside -> out
892  * *****************************************************************************************************************/
893 
894  // Loop over all possible ME11 segment to form seeds:
895  index = -1;
896  for (SegmentContainer::iterator it = CSClist0F.begin(); it != CSClist0F.end(); ++it) {
897  index++;
898 
899  if (usedCSClist0F[index] == true)
900  continue;
901  if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
902  continue;
903 
904  //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
905  //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
906 
907  // Global position of starting point for protoTrack
908  GlobalPoint gp = (*it)->globalPosition();
909  float eta_temp = gp.eta();
910  float phi_temp = gp.phi();
911  bool showeringBefore = false;
912  NShowerSeg = 0;
913  if (IdentifyShowering(CSClist0F, usedCSClist0F, eta_temp, phi_temp, 0, NShowerSeg))
914  showeringBefore = true;
915  int NShowers = 0;
916  if (showeringBefore) {
917  // usedCSClist0F[index] = true;
918  NShowers++;
919  }
920 
921  SegmentContainer protoTrack;
922  protoTrack.push_back(*it);
923 
924  std::vector<int> layers;
925  layers.push_back(0);
926 
927  // Try adding segment from other station
928  if (foundMatchingSegment(
929  1, protoTrack, CSClist1F, usedCSClist1F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
930  layers.push_back(1);
931  if (showeringBefore)
932  NShowers++;
933  if (foundMatchingSegment(
934  1, protoTrack, CSClist2F, usedCSClist2F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
935  layers.push_back(2);
936  if (showeringBefore)
937  NShowers++;
938  if (foundMatchingSegment(
939  1, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
940  layers.push_back(3);
941  if (showeringBefore)
942  NShowers++;
943  if (foundMatchingSegment(
944  1, protoTrack, CSClist4F, usedCSClist4F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
945  layers.push_back(4);
946  if (showeringBefore)
947  NShowers++;
948 
949  // adding showering information
950  if (layers.size() < 2 && !ShoweringSegments.empty()) {
951  for (size_t i = 0; i < ShoweringSegments.size(); i++) {
952  if (ShoweringLayers[i] <= layers[layers.size() - 1])
953  continue;
954  protoTrack.push_back(ShoweringSegments[i]);
955  layers.push_back(ShoweringLayers[i]);
956  }
957  }
958  ShoweringSegments.clear();
959  ShoweringLayers.clear();
960 
961  TrajectorySeed thisSeed;
962  if (layers.size() < 2) {
963  thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
964  } else {
965  if (fabs(gp.eta()) > 1.7) {
966  thisSeed = muonSeedCreate_->createSeed(5, protoTrack, layers, NShowers, NShowerSeg);
967  } else {
968  thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
969  }
970  }
971  // Add the seeds to master collection
972  rawSeeds.push_back(thisSeed);
973  etaOfSeed.push_back(eta_temp);
974  phiOfSeed.push_back(phi_temp);
975  nSegOnSeed.push_back(protoTrack.size());
976 
977  // mark this segment as used
978  usedCSClist0F[index] = true;
979  }
980 
981  // Loop over all possible ME1/2 ME1/3 segment to form seeds:
982  index = -1;
983  for (SegmentContainer::iterator it = CSClist1F.begin(); it != CSClist1F.end(); ++it) {
984  index++;
985 
986  if (usedCSClist1F[index] == true)
987  continue;
988  if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
989  continue;
990 
991  //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
992  //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
993 
994  // Global position of starting point for protoTrack
995  GlobalPoint gp = (*it)->globalPosition();
996  float eta_temp = gp.eta();
997  float phi_temp = gp.phi();
998  bool showeringBefore = false;
999  NShowerSeg = 0;
1000  if (IdentifyShowering(CSClist1F, usedCSClist1F, eta_temp, phi_temp, 1, NShowerSeg))
1001  showeringBefore = true;
1002  int NShowers = 0;
1003  if (showeringBefore) {
1004  // usedCSClist1F[index] = true;
1005  NShowers++;
1006  }
1007 
1008  SegmentContainer protoTrack;
1009  protoTrack.push_back(*it);
1010 
1011  std::vector<int> layers;
1012  layers.push_back(1);
1013 
1014  // Try adding segment from other stations
1015  if (foundMatchingSegment(
1016  1, protoTrack, CSClist2F, usedCSClist2F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
1017  layers.push_back(2);
1018  if (showeringBefore)
1019  NShowers++;
1020  if (foundMatchingSegment(
1021  1, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
1022  layers.push_back(3);
1023  if (showeringBefore)
1024  NShowers++;
1025  if (foundMatchingSegment(
1026  1, protoTrack, CSClist4F, usedCSClist4F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
1027  layers.push_back(4);
1028  if (showeringBefore)
1029  NShowers++;
1030 
1031  // adding showering information
1032  if (layers.size() < 2 && !ShoweringSegments.empty()) {
1033  for (size_t i = 0; i < ShoweringSegments.size(); i++) {
1034  if (ShoweringLayers[i] <= layers[layers.size() - 1])
1035  continue;
1036  protoTrack.push_back(ShoweringSegments[i]);
1037  layers.push_back(ShoweringLayers[i]);
1038  }
1039  }
1040  ShoweringSegments.clear();
1041  ShoweringLayers.clear();
1042 
1043  TrajectorySeed thisSeed;
1044  if (layers.size() < 2) {
1045  thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
1046  } else {
1047  thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
1048  }
1049 
1050  // Add the seeds to master collection
1051  rawSeeds.push_back(thisSeed);
1052  etaOfSeed.push_back(eta_temp);
1053  phiOfSeed.push_back(phi_temp);
1054  nSegOnSeed.push_back(protoTrack.size());
1055 
1056  // mark this segment as used
1057  usedCSClist1F[index] = true;
1058  }
1059 
1060  // Loop over all possible ME2 segment to form seeds:
1061  index = -1;
1062  for (SegmentContainer::iterator it = CSClist2F.begin(); it != CSClist2F.end(); ++it) {
1063  index++;
1064 
1065  if (usedCSClist2F[index] == true)
1066  continue;
1067  if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
1068  continue;
1069 
1070  double dof = static_cast<double>((*it)->degreesOfFreedom());
1071  if (((*it)->chi2() / dof) > 20000.0)
1072  continue;
1073 
1074  // Global position of starting point for protoTrack
1075  GlobalPoint gp = (*it)->globalPosition();
1076  float eta_temp = gp.eta();
1077  float phi_temp = gp.phi();
1078  bool showeringBefore = false;
1079  NShowerSeg = 0;
1080  if (IdentifyShowering(CSClist2F, usedCSClist2F, eta_temp, phi_temp, 2, NShowerSeg))
1081  showeringBefore = true;
1082  int NShowers = 0;
1083  if (showeringBefore) {
1084  // usedCSClist2F[index] = true;
1085  NShowers++;
1086  }
1087 
1088  SegmentContainer protoTrack;
1089  protoTrack.push_back(*it);
1090 
1091  std::vector<int> layers;
1092  layers.push_back(2);
1093 
1094  // Try adding segment from other stations
1095  if (foundMatchingSegment(
1096  1, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
1097  layers.push_back(3);
1098  if (showeringBefore)
1099  NShowers++;
1100  if (foundMatchingSegment(
1101  1, protoTrack, CSClist4F, usedCSClist4F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
1102  layers.push_back(4);
1103  if (showeringBefore)
1104  NShowers++;
1105 
1106  // adding showering information
1107  if (layers.size() < 2 && !ShoweringSegments.empty()) {
1108  for (size_t i = 0; i < ShoweringSegments.size(); i++) {
1109  if (ShoweringLayers[i] <= layers[layers.size() - 1])
1110  continue;
1111  protoTrack.push_back(ShoweringSegments[i]);
1112  layers.push_back(ShoweringLayers[i]);
1113  }
1114  }
1115  ShoweringSegments.clear();
1116  ShoweringLayers.clear();
1117 
1118  TrajectorySeed thisSeed;
1119  if (layers.size() < 2) {
1120  thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
1121  } else {
1122  thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
1123  }
1124 
1125  // Add the seeds to master collection
1126  rawSeeds.push_back(thisSeed);
1127  etaOfSeed.push_back(eta_temp);
1128  phiOfSeed.push_back(phi_temp);
1129  nSegOnSeed.push_back(protoTrack.size());
1130 
1131  // mark this segment as used
1132  usedCSClist2F[index] = true;
1133  }
1134 
1135  // Loop over all possible ME3 segment to form seeds:
1136  index = -1;
1137  for (SegmentContainer::iterator it = CSClist3F.begin(); it != CSClist3F.end(); ++it) {
1138  index++;
1139 
1140  if (usedCSClist3F[index] == true)
1141  continue;
1142  if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
1143  continue;
1144 
1145  double dof = static_cast<double>((*it)->degreesOfFreedom());
1146  if (((*it)->chi2() / dof) > 20000.0)
1147  continue;
1148 
1149  // Global position of starting point for protoTrack
1150  GlobalPoint gp = (*it)->globalPosition();
1151  float eta_temp = gp.eta();
1152  float phi_temp = gp.phi();
1153  bool showeringBefore = false;
1154  NShowerSeg = 0;
1155  if (IdentifyShowering(CSClist3F, usedCSClist3F, eta_temp, phi_temp, 3, NShowerSeg))
1156  showeringBefore = true;
1157  int NShowers = 0;
1158  if (showeringBefore) {
1159  // usedCSClist3F[index] = true;
1160  NShowers++;
1161  }
1162 
1163  SegmentContainer protoTrack;
1164  protoTrack.push_back(*it);
1165 
1166  std::vector<int> layers;
1167  layers.push_back(2);
1168 
1169  // Try adding segment from other stations
1170  if (foundMatchingSegment(
1171  1, protoTrack, CSClist4F, usedCSClist4F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
1172  layers.push_back(4);
1173  if (showeringBefore)
1174  NShowers++;
1175 
1176  // adding showering information
1177  if (layers.size() < 2 && !ShoweringSegments.empty()) {
1178  for (size_t i = 0; i < ShoweringSegments.size(); i++) {
1179  if (ShoweringLayers[i] <= layers[layers.size() - 1])
1180  continue;
1181  protoTrack.push_back(ShoweringSegments[i]);
1182  layers.push_back(ShoweringLayers[i]);
1183  }
1184  }
1185  ShoweringSegments.clear();
1186  ShoweringLayers.clear();
1187 
1188  // mark this segment as used
1189  usedCSClist3F[index] = true;
1190 
1191  if (layers.size() < 2)
1192  continue;
1193 
1194  TrajectorySeed thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
1195 
1196  // Add the seeds to master collection
1197  rawSeeds.push_back(thisSeed);
1198  etaOfSeed.push_back(eta_temp);
1199  phiOfSeed.push_back(phi_temp);
1200  nSegOnSeed.push_back(protoTrack.size());
1201  }
1202 
1203  /* *********************************************************************************************************************
1204  * Clean up raw seed collection and pass to master collection
1205  * *********************************************************************************************************************/
1206 
1207  if (debug)
1208  std::cout << "*** CLEAN UP " << std::endl;
1209  if (debug)
1210  std::cout << "Number of seeds BEFORE " << rawSeeds.size() << std::endl;
1211 
1212  int goodSeeds = 0;
1213 
1214  theSeeds = muonSeedClean_->seedCleaner(eventSetup, rawSeeds);
1215  goodSeeds = theSeeds.size();
1216 
1217  //std::cout << " === Before Cleaning : " << rawSeeds.size() <<std::endl;
1218  //std::cout << " => AFTER :" << goodSeeds << std::endl;
1219 
1220  if (debug)
1221  std::cout << "Number of seeds AFTER " << goodSeeds << std::endl;
1222 
1223  return goodSeeds;
1224 }
MuonSeedBuilder::debug
bool debug
group the seeds
Definition: MuonSeedBuilder.h:106
mps_fire.i
i
Definition: mps_fire.py:428
LayerTriplets::layers
std::vector< LayerSetAndLayers > layers(const SeedingLayerSetsHits &sets)
Definition: LayerTriplets.cc:4
MuonSeedBuilder::SegmentContainer
MuonTransientTrackingRecHit::MuonRecHitContainer SegmentContainer
Definition: MuonSeedBuilder.h:32
MuonSeedBuilder::ShoweringSegments
SegmentContainer ShoweringSegments
Definition: MuonSeedBuilder.h:130
MuonSeedBuilder::IdentifyShowering
bool IdentifyShowering(SegmentContainer &segs, BoolContainer &usedSeg, float &eta_last, float &phi_last, int layer, int &NShoweringSegments)
identify the showering layer
Definition: MuonSeedBuilder.cc:1380
MuonSeedBuilder::foundMatchingSegment
bool foundMatchingSegment(int type, SegmentContainer &protoTrack, SegmentContainer &segments, BoolContainer &usedSeg, float &eta_temp, float &phi_temp, int &lastLayer, bool &showeringBefore)
Find segment which matches protoTrack for endcap only.
Definition: MuonSeedBuilder.cc:1235
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
MuonSeedCreator::createSeed
TrajectorySeed createSeed(int type, const SegmentContainer &seg, const std::vector< int > &layers, int NShower, int NShowerSeg)
Create a seed from set of segments.
Definition: MuonSeedCreator.cc:145
MuonSeedBuilder::muonMeasurements
MuonDetLayerMeasurements * muonMeasurements
Definition: MuonSeedBuilder.h:156
MuonSeedBuilder::muonSeedClean_
MuonSeedCleaner * muonSeedClean_
Definition: MuonSeedBuilder.h:140
MuonSeedBuilder::BField
const MagneticField * BField
Definition: MuonSeedBuilder.h:146
MuonSeedBuilder::BoolContainer
std::deque< bool > BoolContainer
Definition: MuonSeedBuilder.h:33
MuonSeedBuilder::ShoweringLayers
std::vector< int > ShoweringLayers
Definition: MuonSeedBuilder.h:131
MuonDetLayerMeasurements::recHits
MuonRecHitContainer recHits(const DetLayer *layer, const edm::Event &iEvent)
returns the rechits which are on the layer
Definition: MuonDetLayerMeasurements.cc:417
MuonSeedCreator::setBField
void setBField(const MagneticField *theField)
Cache Magnetic Field for current event.
Definition: MuonSeedCreator.h:43
MuonDetLayerGeometry::allDTLayers
const std::vector< const DetLayer * > & allDTLayers() const
return the DT DetLayers (barrel), inside-out
Definition: MuonDetLayerGeometry.cc:150
MuonDetLayerGeometry::forwardCSCLayers
const std::vector< const DetLayer * > & forwardCSCLayers() const
return the forward (+Z) CSC DetLayers, inside-out
Definition: MuonDetLayerGeometry.cc:154
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:73
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:144
MuonSeedCleaner::seedCleaner
std::vector< TrajectorySeed > seedCleaner(const edm::EventSetup &eventSetup, std::vector< TrajectorySeed > &seeds)
Cache pointer to geometry.
Definition: MuonSeedCleaner.cc:72
MuonDetLayerGeometry::backwardCSCLayers
const std::vector< const DetLayer * > & backwardCSCLayers() const
return the backward (-Z) CSC DetLayers, inside-out
Definition: MuonDetLayerGeometry.cc:156
MuonSeedBuilder::muonSeedCreate_
MuonSeedCreator * muonSeedCreate_
Create seed according to region (CSC, DT, Overlap)
Definition: MuonSeedBuilder.h:139
MuonSeedBuilder::muonLayers
const MuonDetLayerGeometry * muonLayers
Definition: MuonSeedBuilder.h:143
double MuonSeedBuilder::etaError ( const GlobalPoint  gp,
double  rErr 
)
private

calculate the eta error from global R error

Definition at line 1457 of file MuonSeedBuilder.cc.

References PV3DBase< T, PVType, FrameType >::mag(), PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::perp2(), and PV3DBase< T, PVType, FrameType >::z().

1457  {
1458  double dHdTheta = 0.0;
1459  double dThetadR = 0.0;
1460  double etaErr = 1.0;
1461 
1462  if (gp.perp() != 0) {
1463  dHdTheta = (gp.mag() + gp.z()) / gp.perp();
1464  dThetadR = gp.z() / gp.perp2();
1465  etaErr = 0.25 * (dHdTheta * dThetadR) * (dHdTheta * dThetadR) * rErr;
1466  }
1467 
1468  return etaErr;
1469 }
PV3DBase::perp
T perp() const
Definition: PV3DBase.h:69
PV3DBase::perp2
T perp2() const
Definition: PV3DBase.h:68
PV3DBase::mag
T mag() const
Definition: PV3DBase.h:64
PV3DBase::z
T z() const
Definition: PV3DBase.h:61
bool MuonSeedBuilder::foundMatchingSegment ( int  type,
SegmentContainer &  protoTrack,
SegmentContainer &  segments,
BoolContainer &  usedSeg,
float &  eta_temp,
float &  phi_temp,
int &  lastLayer,
bool &  showeringBefore 
)
private

Find segment which matches protoTrack for endcap only.

segment for seeding , segments collection

reject possible edge segments

Definition at line 1235 of file MuonSeedBuilder.cc.

References isotrackApplyRegressor::df, cuy::dh, PV3DBase< T, PVType, FrameType >::eta(), IdentifyShowering(), maxDeltaEtaCSC, maxDeltaEtaDT, maxDeltaEtaOverlap, maxDeltaPhiCSC, maxDeltaPhiDT, maxDeltaPhiOverlap, mkfit::Config::maxdEta, mkfit::Config::maxdPhi, minCSCHitsPerSegment, minDTHitsPerSegment, muonSeedClean_, MuonSeedCleaner::NRecHitsFromSegment(), NShowerSeg, convertSQLiteXML::ok, PV3DBase< T, PVType, FrameType >::phi(), and mathSSE::sqrt().

Referenced by build().

1242  {
1243  bool ok = false;
1244  int scanlayer = (lastLayer < 0) ? (lastLayer - 1) : (lastLayer + 1);
1245 
1246  if (IdentifyShowering(segs, usedSeg, eta_last, phi_last, scanlayer, NShowerSeg)) {
1247  showeringBefore = true;
1248  return ok;
1249  }
1250 
1251  // Setup the searching cone-size
1252  // searching cone-size should changes with bending power
1253  double maxdEta;
1254  double maxdPhi;
1255  if (type == 1) {
1256  // CSC
1257  maxdEta = maxDeltaEtaCSC;
1258  if (lastLayer == 0 || lastLayer == 1) {
1259  if (fabs(eta_last) < 2.1) {
1260  maxdPhi = maxDeltaPhiCSC;
1261  } else {
1262  maxdPhi = 0.06;
1263  }
1264  } else if (lastLayer == 2) {
1265  maxdPhi = 0.5 * maxDeltaPhiCSC;
1266  } else {
1267  maxdPhi = 0.2 * maxDeltaPhiCSC;
1268  }
1269 
1270  } else if (type == 2) {
1271  // Overlap
1272  maxdEta = maxDeltaEtaOverlap;
1273  if (lastLayer == -1) {
1274  maxdPhi = maxDeltaPhiDT;
1275  } else {
1276  maxdPhi = maxDeltaPhiOverlap;
1277  }
1278 
1279  } else {
1280  // DT
1281  maxdEta = maxDeltaEtaDT;
1282  if (lastLayer == -1) {
1283  maxdPhi = maxDeltaPhiDT;
1284  } else if (lastLayer == -2) {
1285  maxdPhi = 0.8 * maxDeltaPhiDT;
1286  } else {
1287  maxdPhi = 0.4 * maxDeltaPhiDT;
1288  }
1289  }
1290 
1291  // if previous layer showers, limite the maxdPhi < 0.06
1292  if (showeringBefore && maxdPhi > 0.03)
1293  maxdPhi = 0.03;
1294  // reset the showering flag
1295  showeringBefore = false;
1296 
1297  // global phi/eta from previous segment
1298  float eta_temp = eta_last;
1299  float phi_temp = phi_last;
1300 
1301  // Index counter to keep track of element used in segs
1302  int index = -1;
1303  int best_match = index;
1304  float best_R = sqrt((maxdEta * maxdEta) + (maxdPhi * maxdPhi));
1305  float best_chi2 = 200;
1306  int best_dimension = 2;
1307  int best_nhits = minDTHitsPerSegment;
1308  if (type == 1)
1309  best_nhits = minCSCHitsPerSegment;
1310  // Loop over segments in other station (layer) and find candidate match
1311  for (SegmentContainer::iterator it = segs.begin(); it != segs.end(); ++it) {
1312  index++;
1313 
1314  // Not to get confused: eta_last is from the previous layer.
1315  // This is only to find the best set of segments by comparing at the distance layer-by-layer
1316  GlobalPoint gp2 = (*it)->globalPosition();
1317  double dh = fabs(gp2.eta() - eta_temp);
1318  double df = fabs(gp2.phi() - phi_temp);
1319  double dR = sqrt((dh * dh) + (df * df));
1320 
1321  // dEta and dPhi should be within certain range
1322  bool case1 = (dh < maxdEta && df < maxdPhi) ? true : false;
1323  // for DT station 4 ; CSCSegment is always 4D
1324  bool case2 = (((*it)->dimension() != 4) && (dh < 0.5) && (df < maxdPhi)) ? true : false;
1325  if (!case1 && !case2)
1326  continue;
1327 
1328  int NRechits = muonSeedClean_->NRecHitsFromSegment(&*(*it));
1329 
1330  if (NRechits < best_nhits)
1331  continue;
1332  best_nhits = NRechits;
1333 
1334  // reject 2D segments if 4D segments are available
1335  if ((*it)->dimension() < best_dimension)
1336  continue;
1337  best_dimension = (*it)->dimension();
1338 
1339  // pick the segment with best chi2/dof within a fixed cone size
1340  if (dR > best_R)
1341  continue;
1342 
1343  // select smaller chi2/dof
1344  double dof = static_cast<double>((*it)->degreesOfFreedom());
1346  if ((*it)->chi2() / dof < 0.001 && NRechits < 6 && type == 1)
1347  continue;
1348  if ((*it)->chi2() / dof > best_chi2)
1349  continue;
1350  best_chi2 = (*it)->chi2() / dof;
1351  best_match = index;
1352  // propagate the eta and phi to next layer
1353  if ((*it)->dimension() != 4) {
1354  // Self assignment, is this a bug??
1355  // should this have been (phi/eta)_last = (phi/eta)_temp to make it reset?
1356  //phi_last = phi_last;
1357  //eta_last = eta_last;
1358  } else {
1359  phi_last = gp2.phi();
1360  eta_last = gp2.eta();
1361  }
1362  }
1363 
1364  if (best_match < 0)
1365  return ok;
1366 
1367  // Add best matching segment to protoTrack:
1368  index = -1;
1369  for (SegmentContainer::iterator it = segs.begin(); it != segs.end(); ++it) {
1370  index++;
1371  if (index != best_match)
1372  continue;
1373  protoTrack.push_back(*it);
1374  usedSeg[best_match] = true;
1375  ok = true;
1376  }
1377  return ok;
1378 }
MuonSeedBuilder::IdentifyShowering
bool IdentifyShowering(SegmentContainer &segs, BoolContainer &usedSeg, float &eta_last, float &phi_last, int layer, int &NShoweringSegments)
identify the showering layer
Definition: MuonSeedBuilder.cc:1380
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
type
type
Definition: SiPixelVCal_PayloadInspector.cc:39
MuonSeedBuilder::muonSeedClean_
MuonSeedCleaner * muonSeedClean_
Definition: MuonSeedBuilder.h:140
mkfit::Config::maxdEta
const float maxdEta
Definition: Config.cc:33
mkfit::Config::maxdPhi
const float maxdPhi
Definition: Config.cc:32
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
MuonSeedCleaner::NRecHitsFromSegment
int NRecHitsFromSegment(const TrackingRecHit &rhit)
Definition: MuonSeedCleaner.cc:449
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:73
cuy.dh
tuple dh
Definition: cuy.py:354
bool MuonSeedBuilder::IdentifyShowering ( SegmentContainer &  segs,
BoolContainer &  usedSeg,
float &  eta_last,
float &  phi_last,
int  layer,
int &  NShoweringSegments 
)
private

identify the showering layer

Definition at line 1380 of file MuonSeedBuilder.cc.

References isotrackApplyRegressor::df, cuy::dh, MuonSubdetId::DT, PV3DBase< T, PVType, FrameType >::eta(), runTauDisplay::gp, GeomDetEnumerators::isDT(), muonSeedClean_, MuonSeedCleaner::NRecHitsFromSegment(), PV3DBase< T, PVType, FrameType >::phi(), ShoweringLayers, ShoweringSegments, mathSSE::sqrt(), and DetId::subdetId().

Referenced by build(), and foundMatchingSegment().

1385  {
1386  bool showering = false;
1387 
1388  int nSeg = 0;
1389  int nRhits = 0;
1390  double nChi2 = 9999.;
1391  int theOrigin = -1;
1392  std::vector<int> badtag;
1393  int index = -1;
1394  double aveEta = 0.0;
1395  for (SegmentContainer::iterator it = segs.begin(); it != segs.end(); ++it) {
1396  index++;
1397  GlobalPoint gp = (*it)->globalPosition();
1398  double dh = gp.eta() - eta_last;
1399  double df = gp.phi() - phi_last;
1400  double dR = sqrt((dh * dh) + (df * df));
1401 
1402  double dof = static_cast<double>((*it)->degreesOfFreedom());
1403  double nX2 = (*it)->chi2() / dof;
1404 
1405  bool isDT = false;
1406  DetId geoId = (*it)->geographicalId();
1407  if (geoId.subdetId() == MuonSubdetId::DT)
1408  isDT = true;
1409 
1410  if (dR < 0.3) {
1411  nSeg++;
1412  badtag.push_back(index);
1413  aveEta += fabs(gp.eta());
1414  // pick up the best segment from showering chamber
1415  int rh = muonSeedClean_->NRecHitsFromSegment(&*(*it));
1416  if (rh < 6 && !isDT)
1417  continue;
1418  if (rh < 12 && isDT)
1419  continue;
1420  if (rh > nRhits) {
1421  nRhits = rh;
1422  if (nX2 > nChi2)
1423  continue;
1424  if (layer != 0 && layer != 1 && layer != -1) {
1425  theOrigin = index;
1426  }
1427  }
1428  }
1429  }
1430  aveEta = aveEta / static_cast<double>(nSeg);
1431  bool isME11A = (aveEta >= 2.1 && layer == 0) ? true : false;
1432  bool isME12 = (aveEta > 1.2 && aveEta <= 1.65 && layer == 1) ? true : false;
1433  bool isME11 = (aveEta > 1.65 && aveEta <= 2.1 && layer == 0) ? true : false;
1434  bool is1stLayer = (layer == -1 || layer == 0 || isME12 || isME11 || isME11A) ? true : false;
1435 
1436  NShoweringSegments += nSeg;
1437 
1438  if (nSeg > 3 && !isME11A)
1439  showering = true;
1440  if (nSeg > 6 && isME11A)
1441  showering = true;
1442 
1443  // if showering, flag all segments in order to skip this layer for pt estimation except 1st layer
1444  //std::cout<<" from Showering "<<std::endl;
1445  if (showering && !is1stLayer) {
1446  for (std::vector<int>::iterator it = badtag.begin(); it != badtag.end(); ++it) {
1447  usedSeg[*it] = true;
1448  if ((*it) != theOrigin)
1449  continue;
1450  ShoweringSegments.push_back(segs[*it]);
1451  ShoweringLayers.push_back(layer);
1452  }
1453  }
1454  return showering;
1455 }
MuonSeedBuilder::ShoweringSegments
SegmentContainer ShoweringSegments
Definition: MuonSeedBuilder.h:130
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
GeomDetEnumerators::isDT
bool isDT(GeomDetEnumerators::SubDetector m)
Definition: GeomDetEnumerators.cc:86
phase1PixelTopology::layer
constexpr std::array< uint8_t, layerIndexSize > layer
Definition: SimplePixelTopology.h:138
MuonSeedBuilder::muonSeedClean_
MuonSeedCleaner * muonSeedClean_
Definition: MuonSeedBuilder.h:140
MuonSeedBuilder::ShoweringLayers
std::vector< int > ShoweringLayers
Definition: MuonSeedBuilder.h:131
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:48
DetId
Definition: DetId.h:17
MuonSeedCleaner::NRecHitsFromSegment
int NRecHitsFromSegment(const TrackingRecHit &rhit)
Definition: MuonSeedCleaner.cc:449
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:73
MuonSubdetId::DT
static constexpr int DT
Definition: MuonSubdetId.h:11
cuy.dh
tuple dh
Definition: cuy.py:354
std::vector<TrajectorySeed> MuonSeedBuilder::seedCleaner ( const edm::EventSetup &  eventSetup,
std::vector< TrajectorySeed > &  seeds 
)
private

cleaning the seeds

void MuonSeedBuilder::setBField ( const MagneticField *  theField)
inline

Cache pointer to Magnetic field.

Definition at line 47 of file MuonSeedBuilder.h.

References BField.

Referenced by MuonSeedProducer::produce().

47 { BField = theField; }
MuonSeedBuilder::BField
const MagneticField * BField
Definition: MuonSeedBuilder.h:146
void MuonSeedBuilder::setGeometry ( const MuonDetLayerGeometry *  lgeom)
inline

Cache pointer to geometry.

Definition at line 44 of file MuonSeedBuilder.h.

References muonLayers.

Referenced by MuonSeedProducer::produce().

44 { muonLayers = lgeom; }
MuonSeedBuilder::muonLayers
const MuonDetLayerGeometry * muonLayers
Definition: MuonSeedBuilder.h:143

Member Data Documentation

std::vector<int> MuonSeedBuilder::badSeedLayer

Definition at line 52 of file MuonSeedBuilder.h.

const MagneticField* MuonSeedBuilder::BField
private

Definition at line 146 of file MuonSeedBuilder.h.

Referenced by build(), and setBField().

bool MuonSeedBuilder::debug
private

group the seeds

pick the seed by better parameter error filter out the bad pt seeds, if all are bad pt seeds then keep all collect long seeds pick the seeds w/ 1st layer information and w/ more than 1 segments check overlapping segment for seeds retrieve number of rechits& normalized chi2 of associated segments of a seed retrieve seed global position retrieve seed global momentum

Definition at line 106 of file MuonSeedBuilder.h.

Referenced by build(), runTauIdMVA.TauIDEmbedder::loadMVA_WPs_run2_2017(), MuonSeedBuilder(), and runTauIdMVA.TauIDEmbedder::runTauID().

bool MuonSeedBuilder::enableCSCMeasurement
private

Definition at line 112 of file MuonSeedBuilder.h.

Referenced by MuonSeedBuilder().

bool MuonSeedBuilder::enableDTMeasurement
private

Definition at line 109 of file MuonSeedBuilder.h.

Referenced by MuonSeedBuilder().

float MuonSeedBuilder::maxDeltaEtaCSC
private

Definition at line 121 of file MuonSeedBuilder.h.

Referenced by foundMatchingSegment(), and MuonSeedBuilder().

float MuonSeedBuilder::maxDeltaEtaDT
private

Definition at line 125 of file MuonSeedBuilder.h.

Referenced by foundMatchingSegment(), and MuonSeedBuilder().

float MuonSeedBuilder::maxDeltaEtaOverlap
private

Definition at line 123 of file MuonSeedBuilder.h.

Referenced by foundMatchingSegment(), and MuonSeedBuilder().

float MuonSeedBuilder::maxDeltaPhiCSC
private

Definition at line 122 of file MuonSeedBuilder.h.

Referenced by foundMatchingSegment(), and MuonSeedBuilder().

float MuonSeedBuilder::maxDeltaPhiDT
private

Definition at line 126 of file MuonSeedBuilder.h.

Referenced by foundMatchingSegment(), and MuonSeedBuilder().

float MuonSeedBuilder::maxDeltaPhiOverlap
private

Definition at line 124 of file MuonSeedBuilder.h.

Referenced by foundMatchingSegment(), and MuonSeedBuilder().

float MuonSeedBuilder::maxEtaResolutionCSC
private

Definition at line 151 of file MuonSeedBuilder.h.

Referenced by MuonSeedBuilder().

float MuonSeedBuilder::maxEtaResolutionDT
private

Definition at line 150 of file MuonSeedBuilder.h.

Referenced by MuonSeedBuilder().

float MuonSeedBuilder::maxPhiResolutionCSC
private

Definition at line 153 of file MuonSeedBuilder.h.

Referenced by MuonSeedBuilder().

float MuonSeedBuilder::maxPhiResolutionDT
private

Definition at line 152 of file MuonSeedBuilder.h.

Referenced by MuonSeedBuilder().

int MuonSeedBuilder::minCSCHitsPerSegment
private

Definition at line 115 of file MuonSeedBuilder.h.

Referenced by build(), foundMatchingSegment(), and MuonSeedBuilder().

int MuonSeedBuilder::minDTHitsPerSegment
private

Definition at line 118 of file MuonSeedBuilder.h.

Referenced by build(), foundMatchingSegment(), and MuonSeedBuilder().

const MuonDetLayerGeometry* MuonSeedBuilder::muonLayers
private

Definition at line 143 of file MuonSeedBuilder.h.

Referenced by build(), and setGeometry().

MuonDetLayerMeasurements* MuonSeedBuilder::muonMeasurements
private

Definition at line 156 of file MuonSeedBuilder.h.

Referenced by build(), MuonSeedBuilder(), and ~MuonSeedBuilder().

MuonSeedCleaner* MuonSeedBuilder::muonSeedClean_
private

Definition at line 140 of file MuonSeedBuilder.h.

Referenced by build(), foundMatchingSegment(), IdentifyShowering(), MuonSeedBuilder(), and ~MuonSeedBuilder().

MuonSeedCreator* MuonSeedBuilder::muonSeedCreate_
private

Create seed according to region (CSC, DT, Overlap)

Definition at line 139 of file MuonSeedBuilder.h.

Referenced by build(), MuonSeedBuilder(), and ~MuonSeedBuilder().

int MuonSeedBuilder::NShowerSeg
private

Definition at line 129 of file MuonSeedBuilder.h.

Referenced by build(), and foundMatchingSegment().

std::vector<int> MuonSeedBuilder::ShoweringLayers
private

Definition at line 131 of file MuonSeedBuilder.h.

Referenced by build(), and IdentifyShowering().

SegmentContainer MuonSeedBuilder::ShoweringSegments
private

Definition at line 130 of file MuonSeedBuilder.h.

Referenced by build(), and IdentifyShowering().

edm::InputTag MuonSeedBuilder::theCSCSegmentLabel
private

Name of the CSC segment collection.

Definition at line 136 of file MuonSeedBuilder.h.

Referenced by MuonSeedBuilder().

edm::InputTag MuonSeedBuilder::theDTSegmentLabel
private

Name of the DT segment collection.

Definition at line 133 of file MuonSeedBuilder.h.

Referenced by MuonSeedBuilder().

float MuonSeedBuilder::theMinMomentum
private

Definition at line 154 of file MuonSeedBuilder.h.

Generated for CMSSW Reference Manual by doxygen 1.8.5