#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

MuonServiceProxy *	theService

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 33 of file MuonSeedBuilder.h.

Member Typedef Documentation

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

Definition at line 36 of file MuonSeedBuilder.h.

typedef MuonTransientTrackingRecHit::MuonRecHitContainer MuonSeedBuilder::SegmentContainer

Definition at line 35 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_, MuonServiceProxy_cff::MuonServiceProxy, theCSCSegmentLabel, theDTSegmentLabel, and theService.

                                                                                       {
   // Local Debug flag
   debug = pset.getParameter<bool>("DebugMuonSeed");
 
   // enable the DT chamber
   enableDTMeasurement = pset.getParameter<bool>("EnableDTMeasurement");
   theDTSegmentLabel = pset.getParameter<edm::InputTag>("DTSegmentLabel");
 
   // enable the CSC chamber
   enableCSCMeasurement = pset.getParameter<bool>("EnableCSCMeasurement");
   theCSCSegmentLabel = pset.getParameter<edm::InputTag>("CSCSegmentLabel");
 
   // Parameters for seed creation in endcap region
   minCSCHitsPerSegment = pset.getParameter<int>("minCSCHitsPerSegment");
   maxDeltaEtaCSC = pset.getParameter<double>("maxDeltaEtaCSC");
   maxDeltaPhiCSC = pset.getParameter<double>("maxDeltaPhiCSC");
 
   // Parameters for seed creation in overlap region
   maxDeltaEtaOverlap = pset.getParameter<double>("maxDeltaEtaOverlap");
   maxDeltaPhiOverlap = pset.getParameter<double>("maxDeltaPhiOverlap");
 
   // Parameters for seed creation in barrel region
   minDTHitsPerSegment = pset.getParameter<int>("minDTHitsPerSegment");
   maxDeltaEtaDT = pset.getParameter<double>("maxDeltaEtaDT");
   maxDeltaPhiDT = pset.getParameter<double>("maxDeltaPhiDT");
 
   // Parameters to suppress combinatorics (ghosts)
   maxEtaResolutionDT = pset.getParameter<double>("maxEtaResolutionDT");
   maxPhiResolutionDT = pset.getParameter<double>("maxPhiResolutionDT");
   maxEtaResolutionCSC = pset.getParameter<double>("maxEtaResolutionCSC");
   maxPhiResolutionCSC = pset.getParameter<double>("maxPhiResolutionCSC");
 
   // muon service
   edm::ParameterSet serviceParameters = pset.getParameter<edm::ParameterSet>("ServiceParameters");
   theService = new MuonServiceProxy(serviceParameters);
 
   // Class for forming muon seeds
   muonSeedCreate_ = new MuonSeedCreator(pset);
   muonSeedClean_ = new MuonSeedCleaner(pset);
 
   // Instantiate the accessor (get the segments: DT + CSC but not RPC=false)
   muonMeasurements = new MuonDetLayerMeasurements(theDTSegmentLabel,
                                                   theCSCSegmentLabel,
                                                   edm::InputTag(),
                                                   edm::InputTag(),
                                                   edm::InputTag(),
                                                   iC,
                                                   enableDTMeasurement,
                                                   enableCSCMeasurement,
                                                   false,
                                                   false,
                                                   false);
 }

MuonSeedBuilder::~MuonSeedBuilder ( )

Destructor.

Definition at line 108 of file MuonSeedBuilder.cc.

References muonMeasurements, muonSeedClean_, muonSeedCreate_, and theService.

                                   {
   delete muonSeedCreate_;
   delete muonSeedClean_;
   if (theService)
     delete theService;
   if (muonMeasurements)
     delete muonMeasurements;
 }

Member Function Documentation

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

Build seed collection.

Definition at line 125 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(), hgcalTopologyTester_cfi::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(), and setBField().

                                                                                                                {
   // Pass the Magnetic Field to where the seed is create
   muonSeedCreate_->setBField(BField);
 
   // Create temporary collection of seeds which will be cleaned up to remove combinatorics
   std::vector<TrajectorySeed> rawSeeds;
   std::vector<float> etaOfSeed;
   std::vector<float> phiOfSeed;
   std::vector<int> nSegOnSeed;
 
   // Instantiate the accessor (get the segments: DT + CSC but not RPC=false)
   // MuonDetLayerMeasurements muonMeasurements(enableDTMeasurement,enableCSCMeasurement,false,
   //                                          theDTSegmentLabel.label(),theCSCSegmentLabel.label());
 
   // 1) Get the various stations and store segments in containers for each station (layers)
 
   // 1a. get the DT segments by stations (layers):
   std::vector<const DetLayer*> dtLayers = muonLayers->allDTLayers();
 
   SegmentContainer DTlist4 = muonMeasurements->recHits(dtLayers[3], event);
   SegmentContainer DTlist3 = muonMeasurements->recHits(dtLayers[2], event);
   SegmentContainer DTlist2 = muonMeasurements->recHits(dtLayers[1], event);
   SegmentContainer DTlist1 = muonMeasurements->recHits(dtLayers[0], event);
 
   // Initialize flags that a given segment has been allocated to a seed
   BoolContainer usedDTlist4(DTlist4.size(), false);
   BoolContainer usedDTlist3(DTlist3.size(), false);
   BoolContainer usedDTlist2(DTlist2.size(), false);
   BoolContainer usedDTlist1(DTlist1.size(), false);
 
   if (debug) {
     std::cout << "*** Number of DT segments is: " << DTlist4.size() + DTlist3.size() + DTlist2.size() + DTlist1.size()
               << std::endl;
     std::cout << "In MB1: " << DTlist1.size() << std::endl;
     std::cout << "In MB2: " << DTlist2.size() << std::endl;
     std::cout << "In MB3: " << DTlist3.size() << std::endl;
     std::cout << "In MB4: " << DTlist4.size() << std::endl;
   }
 
   // 1b. get the CSC segments by stations (layers):
   // 1b.1 Global z < 0
   std::vector<const DetLayer*> cscBackwardLayers = muonLayers->backwardCSCLayers();
   SegmentContainer CSClist4B = muonMeasurements->recHits(cscBackwardLayers[4], event);
   SegmentContainer CSClist3B = muonMeasurements->recHits(cscBackwardLayers[3], event);
   SegmentContainer CSClist2B = muonMeasurements->recHits(cscBackwardLayers[2], event);
   SegmentContainer CSClist1B = muonMeasurements->recHits(cscBackwardLayers[1], event);  // ME1/2 and 1/3
   SegmentContainer CSClist0B = muonMeasurements->recHits(cscBackwardLayers[0], event);  // ME11
 
   BoolContainer usedCSClist4B(CSClist4B.size(), false);
   BoolContainer usedCSClist3B(CSClist3B.size(), false);
   BoolContainer usedCSClist2B(CSClist2B.size(), false);
   BoolContainer usedCSClist1B(CSClist1B.size(), false);
   BoolContainer usedCSClist0B(CSClist0B.size(), false);
 
   // 1b.2 Global z > 0
   std::vector<const DetLayer*> cscForwardLayers = muonLayers->forwardCSCLayers();
   SegmentContainer CSClist4F = muonMeasurements->recHits(cscForwardLayers[4], event);
   SegmentContainer CSClist3F = muonMeasurements->recHits(cscForwardLayers[3], event);
   SegmentContainer CSClist2F = muonMeasurements->recHits(cscForwardLayers[2], event);
   SegmentContainer CSClist1F = muonMeasurements->recHits(cscForwardLayers[1], event);
   SegmentContainer CSClist0F = muonMeasurements->recHits(cscForwardLayers[0], event);
 
   BoolContainer usedCSClist4F(CSClist4F.size(), false);
   BoolContainer usedCSClist3F(CSClist3F.size(), false);
   BoolContainer usedCSClist2F(CSClist2F.size(), false);
   BoolContainer usedCSClist1F(CSClist1F.size(), false);
   BoolContainer usedCSClist0F(CSClist0F.size(), false);
 
   if (debug) {
     std::cout << "*** Number of CSC segments is "
               << CSClist4F.size() + CSClist3F.size() + CSClist2F.size() + CSClist1F.size() + CSClist0F.size() +
                      CSClist4B.size() + CSClist3B.size() + CSClist2B.size() + CSClist1B.size() + CSClist0B.size()
               << std::endl;
     std::cout << "In ME11: " << CSClist0F.size() + CSClist0B.size() << std::endl;
     std::cout << "In ME12: " << CSClist1F.size() + CSClist1B.size() << std::endl;
     std::cout << "In ME2 : " << CSClist2F.size() + CSClist2B.size() << std::endl;
     std::cout << "In ME3 : " << CSClist3F.size() + CSClist3B.size() << std::endl;
     std::cout << "In ME4 : " << CSClist4F.size() + CSClist4B.size() << std::endl;
   }
 
   /* ******************************************************************************************************************
    * Form seeds in barrel region
    *
    * Proceed from inside -> out
    * ******************************************************************************************************************/
 
   // Loop over all possible MB1 segment to form seeds:
   int index = -1;
   for (SegmentContainer::iterator it = DTlist1.begin(); it != DTlist1.end(); ++it) {
     index++;
 
     if (usedDTlist1[index] == true)
       continue;
     if (int((*it)->recHits().size()) < minDTHitsPerSegment)
       continue;
     if ((*it)->dimension() != 4)
       continue;
 
     //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
     //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
 
     // Global position of starting point for protoTrack
     GlobalPoint gp = (*it)->globalPosition();
     float eta_temp = gp.eta();
     float phi_temp = gp.phi();
     bool showeringBefore = false;
     NShowerSeg = 0;
     if (IdentifyShowering(DTlist1, usedDTlist1, eta_temp, phi_temp, -1, NShowerSeg))
       showeringBefore = true;
     int NShowers = 0;
     if (showeringBefore) {
       //usedDTlist1[index] = true;
       NShowers++;
     }
 
     SegmentContainer protoTrack;
     protoTrack.push_back(*it);
 
     std::vector<int> layers;
     layers.push_back(-1);
 
     // Try adding segment from other stations
     if (foundMatchingSegment(
             3, protoTrack, DTlist2, usedDTlist2, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(-2);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             3, protoTrack, DTlist3, usedDTlist3, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(-3);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             3, protoTrack, DTlist4, usedDTlist4, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(-4);
     if (showeringBefore)
       NShowers++;
 
     // Check if in overlap region
     if (eta_temp > 0.8) {
       if (foundMatchingSegment(
               2, protoTrack, CSClist1F, usedCSClist1F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(1);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist2F, usedCSClist2F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(2);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(3);
       if (showeringBefore)
         NShowers++;
     } else if (eta_temp < -0.8) {
       if (foundMatchingSegment(
               2, protoTrack, CSClist1B, usedCSClist1B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(1);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist2B, usedCSClist2B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(2);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(3);
       if (showeringBefore)
         NShowers++;
     }
 
     // adding showering information
     if (layers.size() < 2 && !ShoweringSegments.empty()) {
       for (size_t i = 0; i < ShoweringSegments.size(); i++) {
         if (ShoweringLayers[i] > 0) {
           if (ShoweringLayers[i] <= layers[layers.size() - 1])
             continue;
           protoTrack.push_back(ShoweringSegments[i]);
           layers.push_back(ShoweringLayers[i]);
         }
         if (ShoweringLayers[i] < 0 && layers[layers.size() - 1] < 0) {
           if (ShoweringLayers[i] >= layers[layers.size() - 1])
             continue;
           protoTrack.push_back(ShoweringSegments[i]);
           layers.push_back(ShoweringLayers[i]);
         }
       }
     }
     ShoweringSegments.clear();
     ShoweringLayers.clear();
 
     TrajectorySeed thisSeed;
 
     if (layers.size() < 2) {
       thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
     } else {
       if (layers[layers.size() - 1] > 0) {
         thisSeed = muonSeedCreate_->createSeed(2, protoTrack, layers, NShowers, NShowerSeg);
       } else {
         thisSeed = muonSeedCreate_->createSeed(3, protoTrack, layers, NShowers, NShowerSeg);
       }
     }
     // Add the seeds to master collection
     rawSeeds.push_back(thisSeed);
     etaOfSeed.push_back(eta_temp);
     phiOfSeed.push_back(phi_temp);
     nSegOnSeed.push_back(protoTrack.size());
 
     // Marked segment as used
     usedDTlist1[index] = true;
   }
 
   // Loop over all possible MB2 segment to form seeds:
   index = -1;
   for (SegmentContainer::iterator it = DTlist2.begin(); it != DTlist2.end(); ++it) {
     index++;
 
     if (usedDTlist2[index] == true)
       continue;
     if (int((*it)->recHits().size()) < minDTHitsPerSegment)
       continue;
     if ((*it)->dimension() != 4)
       continue;
 
     //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
     //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
 
     // Global position of starting point for protoTrack
     GlobalPoint gp = (*it)->globalPosition();
     float eta_temp = gp.eta();
     float phi_temp = gp.phi();
     bool showeringBefore = false;
     NShowerSeg = 0;
     if (IdentifyShowering(DTlist2, usedDTlist2, eta_temp, phi_temp, -2, NShowerSeg))
       showeringBefore = true;
     int NShowers = 0;
     if (showeringBefore) {
       // usedDTlist2[index] = true;
       NShowers++;
     }
 
     SegmentContainer protoTrack;
     protoTrack.push_back(*it);
 
     std::vector<int> layers;
     layers.push_back(-2);
 
     // Try adding segment from other stations
     if (foundMatchingSegment(
             3, protoTrack, DTlist3, usedDTlist3, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(-3);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             3, protoTrack, DTlist4, usedDTlist4, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(-4);
     if (showeringBefore)
       NShowers++;
 
     // Check if in overlap region
     if (eta_temp > 0.8) {
       if (foundMatchingSegment(
               2, protoTrack, CSClist1F, usedCSClist1F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(1);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist2F, usedCSClist2F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(2);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(3);
       if (showeringBefore)
         NShowers++;
     } else if (eta_temp < -0.8) {
       if (foundMatchingSegment(
               2, protoTrack, CSClist1B, usedCSClist1B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(1);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist2B, usedCSClist2B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(2);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(3);
       if (showeringBefore)
         NShowers++;
     }
 
     // adding showering information
     if (layers.size() < 2 && !ShoweringSegments.empty()) {
       for (size_t i = 0; i < ShoweringSegments.size(); i++) {
         if (ShoweringLayers[i] > 0) {
           if (ShoweringLayers[i] <= layers[layers.size() - 1])
             continue;
           protoTrack.push_back(ShoweringSegments[i]);
           layers.push_back(ShoweringLayers[i]);
         }
         if (ShoweringLayers[i] < 0 && layers[layers.size() - 1] < 0) {
           if (ShoweringLayers[i] >= layers[layers.size() - 1])
             continue;
           protoTrack.push_back(ShoweringSegments[i]);
           layers.push_back(ShoweringLayers[i]);
         }
       }
     }
     ShoweringSegments.clear();
     ShoweringLayers.clear();
 
     TrajectorySeed thisSeed;
 
     if (layers.size() < 2) {
       thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
     } else {
       if (layers[layers.size() - 1] > 0) {
         thisSeed = muonSeedCreate_->createSeed(2, protoTrack, layers, NShowers, NShowerSeg);
       } else {
         thisSeed = muonSeedCreate_->createSeed(3, protoTrack, layers, NShowers, NShowerSeg);
       }
     }
     // Add the seeds to master collection
     rawSeeds.push_back(thisSeed);
     etaOfSeed.push_back(eta_temp);
     phiOfSeed.push_back(phi_temp);
     nSegOnSeed.push_back(protoTrack.size());
 
     // Marked segment as used
     usedDTlist2[index] = true;
   }
 
   // Loop over all possible MB3 segment to form seeds:
   index = -1;
   for (SegmentContainer::iterator it = DTlist3.begin(); it != DTlist3.end(); ++it) {
     index++;
 
     if (usedDTlist3[index] == true)
       continue;
     if (int((*it)->recHits().size()) < minDTHitsPerSegment)
       continue;
     if ((*it)->dimension() != 4)
       continue;
 
     //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
     //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
 
     // Global position of starting point for protoTrack
     GlobalPoint gp = (*it)->globalPosition();
     float eta_temp = gp.eta();
     float phi_temp = gp.phi();
     bool showeringBefore = false;
     NShowerSeg = 0;
     if (IdentifyShowering(DTlist3, usedDTlist3, eta_temp, phi_temp, -3, NShowerSeg))
       showeringBefore = true;
     int NShowers = 0;
     if (showeringBefore) {
       // usedDTlist3[index] = true;
       NShowers++;
     }
 
     SegmentContainer protoTrack;
     protoTrack.push_back(*it);
 
     std::vector<int> layers;
     layers.push_back(-3);
 
     // Try adding segment from other stations
     if (foundMatchingSegment(
             3, protoTrack, DTlist4, usedDTlist4, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(-4);
     if (showeringBefore)
       NShowers++;
 
     // Check if in overlap region
     if (eta_temp > 0.8) {
       if (foundMatchingSegment(
               2, protoTrack, CSClist1F, usedCSClist1F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(1);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist2F, usedCSClist2F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(2);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(3);
       if (showeringBefore)
         NShowers++;
     } else if (eta_temp < -0.8) {
       if (foundMatchingSegment(
               2, protoTrack, CSClist1B, usedCSClist1B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(1);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist2B, usedCSClist2B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(2);
       if (showeringBefore)
         NShowers++;
       if (foundMatchingSegment(
               2, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
         layers.push_back(3);
       if (showeringBefore)
         NShowers++;
     }
 
     // adding showering information
     if (layers.size() < 2 && !ShoweringSegments.empty()) {
       for (size_t i = 0; i < ShoweringSegments.size(); i++) {
         if (ShoweringLayers[i] > 0) {
           if (ShoweringLayers[i] <= layers[layers.size() - 1])
             continue;
           protoTrack.push_back(ShoweringSegments[i]);
           layers.push_back(ShoweringLayers[i]);
         }
         if (ShoweringLayers[i] < 0 && layers[layers.size() - 1] < 0) {
           if (ShoweringLayers[i] >= layers[layers.size() - 1])
             continue;
           protoTrack.push_back(ShoweringSegments[i]);
           layers.push_back(ShoweringLayers[i]);
         }
       }
     }
     ShoweringSegments.clear();
     ShoweringLayers.clear();
 
     TrajectorySeed thisSeed;
     if (layers.size() < 2) {
       thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
     } else {
       if (layers[layers.size() - 1] > 0) {
         thisSeed = muonSeedCreate_->createSeed(2, protoTrack, layers, NShowers, NShowerSeg);
       } else {
         thisSeed = muonSeedCreate_->createSeed(3, protoTrack, layers, NShowers, NShowerSeg);
       }
     }
 
     // Add the seeds to master collection
     rawSeeds.push_back(thisSeed);
     etaOfSeed.push_back(eta_temp);
     phiOfSeed.push_back(phi_temp);
     nSegOnSeed.push_back(protoTrack.size());
 
     // Marked segment as used
     usedDTlist3[index] = true;
   }
 
   /* *********************************************************************************************************************
    * Form seeds from backward endcap
    *
    * Proceed from inside -> out
    * *********************************************************************************************************************/
 
   // Loop over all possible ME11 segment to form seeds:
   index = -1;
 
   for (SegmentContainer::iterator it = CSClist0B.begin(); it != CSClist0B.end(); ++it) {
     index++;
 
     if (usedCSClist0B[index] == true)
       continue;
     if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
       continue;
 
     //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
     //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
 
     // Global position of starting point for protoTrack
     GlobalPoint gp = (*it)->globalPosition();
     float eta_temp = gp.eta();
     float phi_temp = gp.phi();
     bool showeringBefore = false;
     NShowerSeg = 0;
     if (IdentifyShowering(CSClist0B, usedCSClist0B, eta_temp, phi_temp, 0, NShowerSeg))
       showeringBefore = true;
     int NShowers = 0;
     if (showeringBefore) {
       // usedCSClist0B[index] = true;
       NShowers++;
     }
 
     SegmentContainer protoTrack;
     protoTrack.push_back(*it);
 
     std::vector<int> layers;
     layers.push_back(0);
 
     // Try adding segment from other station
     if (foundMatchingSegment(
             1, protoTrack, CSClist1B, usedCSClist1B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(1);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist2B, usedCSClist2B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(2);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(3);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist4B, usedCSClist4B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(4);
     if (showeringBefore)
       NShowers++;
 
     // adding showering information
     if (layers.size() < 2 && !ShoweringSegments.empty()) {
       for (size_t i = 0; i < ShoweringSegments.size(); i++) {
         if (ShoweringLayers[i] <= layers[layers.size() - 1])
           continue;
         protoTrack.push_back(ShoweringSegments[i]);
         layers.push_back(ShoweringLayers[i]);
       }
     }
     ShoweringSegments.clear();
     ShoweringLayers.clear();
 
     TrajectorySeed thisSeed;
     if (layers.size() < 2) {
       thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
     } else {
       if (fabs(gp.eta()) > 1.7) {
         thisSeed = muonSeedCreate_->createSeed(5, protoTrack, layers, NShowers, NShowerSeg);
       } else {
         thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
       }
     }
 
     // Add the seeds to master collection
     rawSeeds.push_back(thisSeed);
     etaOfSeed.push_back(eta_temp);
     phiOfSeed.push_back(phi_temp);
     nSegOnSeed.push_back(protoTrack.size());
 
     // mark this segment as used
     usedCSClist0B[index] = true;
   }
 
   // Loop over all possible ME1/2 ME1/3 segment to form seeds:
   index = -1;
   for (SegmentContainer::iterator it = CSClist1B.begin(); it != CSClist1B.end(); ++it) {
     index++;
 
     if (usedCSClist1B[index] == true)
       continue;
     if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
       continue;
 
     //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
     //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
 
     // Global position of starting point for protoTrack
     GlobalPoint gp = (*it)->globalPosition();
     float eta_temp = gp.eta();
     float phi_temp = gp.phi();
     bool showeringBefore = false;
     NShowerSeg = 0;
     if (IdentifyShowering(CSClist1B, usedCSClist1B, eta_temp, phi_temp, 1, NShowerSeg))
       showeringBefore = true;
     int NShowers = 0;
     if (showeringBefore) {
       //    usedCSClist1B[index] = true;
       NShowers++;
     }
 
     SegmentContainer protoTrack;
     protoTrack.push_back(*it);
 
     std::vector<int> layers;
     layers.push_back(1);
 
     // Try adding segment from other stations
     if (foundMatchingSegment(
             1, protoTrack, CSClist2B, usedCSClist2B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(2);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(3);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist4B, usedCSClist4B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(4);
     if (showeringBefore)
       NShowers++;
 
     // adding showering information
     if (layers.size() < 2 && !ShoweringSegments.empty()) {
       for (size_t i = 0; i < ShoweringSegments.size(); i++) {
         if (ShoweringLayers[i] <= layers[layers.size() - 1])
           continue;
         protoTrack.push_back(ShoweringSegments[i]);
         layers.push_back(ShoweringLayers[i]);
       }
     }
     ShoweringSegments.clear();
     ShoweringLayers.clear();
 
     TrajectorySeed thisSeed;
     if (layers.size() < 2) {
       thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
     } else {
       thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
     }
     // Add the seeds to master collection
     rawSeeds.push_back(thisSeed);
     etaOfSeed.push_back(eta_temp);
     phiOfSeed.push_back(phi_temp);
     nSegOnSeed.push_back(protoTrack.size());
 
     // mark this segment as used
     usedCSClist1B[index] = true;
   }
 
   // Loop over all possible ME2 segment to form seeds:
   index = -1;
   for (SegmentContainer::iterator it = CSClist2B.begin(); it != CSClist2B.end(); ++it) {
     index++;
 
     if (usedCSClist2B[index] == true)
       continue;
     if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
       continue;
 
     double dof = static_cast<double>((*it)->degreesOfFreedom());
     if (((*it)->chi2() / dof) > 20000.0)
       continue;
 
     // Global position of starting point for protoTrack
     GlobalPoint gp = (*it)->globalPosition();
     float eta_temp = gp.eta();
     float phi_temp = gp.phi();
     bool showeringBefore = false;
     NShowerSeg = 0;
     if (IdentifyShowering(CSClist2B, usedCSClist2B, eta_temp, phi_temp, 2, NShowerSeg))
       showeringBefore = true;
     int NShowers = 0;
     if (showeringBefore) {
       // usedCSClist2B[index] = true;
       NShowers++;
     }
 
     SegmentContainer protoTrack;
     protoTrack.push_back(*it);
 
     std::vector<int> layers;
     layers.push_back(2);
 
     // Try adding segment from other stations
     if (foundMatchingSegment(
             1, protoTrack, CSClist3B, usedCSClist3B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(3);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist4B, usedCSClist4B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(4);
     if (showeringBefore)
       NShowers++;
 
     // adding showering information
     if (layers.size() < 2 && !ShoweringSegments.empty()) {
       for (size_t i = 0; i < ShoweringSegments.size(); i++) {
         if (ShoweringLayers[i] <= layers[layers.size() - 1])
           continue;
         protoTrack.push_back(ShoweringSegments[i]);
         layers.push_back(ShoweringLayers[i]);
       }
     }
     ShoweringSegments.clear();
     ShoweringLayers.clear();
 
     TrajectorySeed thisSeed;
     if (layers.size() < 2) {
       thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
     } else {
       thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
     }
 
     // Add the seeds to master collection
     rawSeeds.push_back(thisSeed);
     etaOfSeed.push_back(eta_temp);
     phiOfSeed.push_back(phi_temp);
     nSegOnSeed.push_back(protoTrack.size());
     // mark this segment as used
     usedCSClist2B[index] = true;
   }
 
   // Loop over all possible ME3 segment to form seeds:
   index = -1;
   for (SegmentContainer::iterator it = CSClist3B.begin(); it != CSClist3B.end(); ++it) {
     index++;
 
     if (usedCSClist3B[index] == true)
       continue;
     if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
       continue;
 
     double dof = static_cast<double>((*it)->degreesOfFreedom());
     if (((*it)->chi2() / dof) > 20000.0)
       continue;
 
     // Global position of starting point for protoTrack
     GlobalPoint gp = (*it)->globalPosition();
     float eta_temp = gp.eta();
     float phi_temp = gp.phi();
     bool showeringBefore = false;
     NShowerSeg = 0;
     if (IdentifyShowering(CSClist3B, usedCSClist3B, eta_temp, phi_temp, 3, NShowerSeg))
       showeringBefore = true;
     int NShowers = 0;
     if (showeringBefore) {
       //    usedCSClist3B[index] = true;
       NShowers++;
     }
 
     SegmentContainer protoTrack;
     protoTrack.push_back(*it);
 
     std::vector<int> layers;
     layers.push_back(2);
 
     // Try adding segment from other stations
     if (foundMatchingSegment(
             1, protoTrack, CSClist4B, usedCSClist4B, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(4);
     if (showeringBefore)
       NShowers++;
 
     // adding showering information
     if (layers.size() < 2 && !ShoweringSegments.empty()) {
       for (size_t i = 0; i < ShoweringSegments.size(); i++) {
         if (ShoweringLayers[i] <= layers[layers.size() - 1])
           continue;
         protoTrack.push_back(ShoweringSegments[i]);
         layers.push_back(ShoweringLayers[i]);
       }
     }
     ShoweringSegments.clear();
     ShoweringLayers.clear();
 
     // mark this segment as used
     usedCSClist3B[index] = true;
 
     if (layers.size() < 2)
       continue;
     TrajectorySeed thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
 
     // Add the seeds to master collection
     rawSeeds.push_back(thisSeed);
     etaOfSeed.push_back(eta_temp);
     phiOfSeed.push_back(phi_temp);
     nSegOnSeed.push_back(protoTrack.size());
   }
 
   /* *****************************************************************************************************************
    * Form seeds from forward endcap
    *
    * Proceed from inside -> out
    * *****************************************************************************************************************/
 
   // Loop over all possible ME11 segment to form seeds:
   index = -1;
   for (SegmentContainer::iterator it = CSClist0F.begin(); it != CSClist0F.end(); ++it) {
     index++;
 
     if (usedCSClist0F[index] == true)
       continue;
     if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
       continue;
 
     //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
     //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
 
     // Global position of starting point for protoTrack
     GlobalPoint gp = (*it)->globalPosition();
     float eta_temp = gp.eta();
     float phi_temp = gp.phi();
     bool showeringBefore = false;
     NShowerSeg = 0;
     if (IdentifyShowering(CSClist0F, usedCSClist0F, eta_temp, phi_temp, 0, NShowerSeg))
       showeringBefore = true;
     int NShowers = 0;
     if (showeringBefore) {
       // usedCSClist0F[index] = true;
       NShowers++;
     }
 
     SegmentContainer protoTrack;
     protoTrack.push_back(*it);
 
     std::vector<int> layers;
     layers.push_back(0);
 
     // Try adding segment from other station
     if (foundMatchingSegment(
             1, protoTrack, CSClist1F, usedCSClist1F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(1);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist2F, usedCSClist2F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(2);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(3);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist4F, usedCSClist4F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(4);
     if (showeringBefore)
       NShowers++;
 
     // adding showering information
     if (layers.size() < 2 && !ShoweringSegments.empty()) {
       for (size_t i = 0; i < ShoweringSegments.size(); i++) {
         if (ShoweringLayers[i] <= layers[layers.size() - 1])
           continue;
         protoTrack.push_back(ShoweringSegments[i]);
         layers.push_back(ShoweringLayers[i]);
       }
     }
     ShoweringSegments.clear();
     ShoweringLayers.clear();
 
     TrajectorySeed thisSeed;
     if (layers.size() < 2) {
       thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
     } else {
       if (fabs(gp.eta()) > 1.7) {
         thisSeed = muonSeedCreate_->createSeed(5, protoTrack, layers, NShowers, NShowerSeg);
       } else {
         thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
       }
     }
     // Add the seeds to master collection
     rawSeeds.push_back(thisSeed);
     etaOfSeed.push_back(eta_temp);
     phiOfSeed.push_back(phi_temp);
     nSegOnSeed.push_back(protoTrack.size());
 
     // mark this segment as used
     usedCSClist0F[index] = true;
   }
 
   // Loop over all possible ME1/2 ME1/3 segment to form seeds:
   index = -1;
   for (SegmentContainer::iterator it = CSClist1F.begin(); it != CSClist1F.end(); ++it) {
     index++;
 
     if (usedCSClist1F[index] == true)
       continue;
     if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
       continue;
 
     //double dof = static_cast<double>( (*it)->degreesOfFreedom() ) ;
     //if ( ((*it)->chi2()/dof) > 20000.0 ) continue;
 
     // Global position of starting point for protoTrack
     GlobalPoint gp = (*it)->globalPosition();
     float eta_temp = gp.eta();
     float phi_temp = gp.phi();
     bool showeringBefore = false;
     NShowerSeg = 0;
     if (IdentifyShowering(CSClist1F, usedCSClist1F, eta_temp, phi_temp, 1, NShowerSeg))
       showeringBefore = true;
     int NShowers = 0;
     if (showeringBefore) {
       //   usedCSClist1F[index] = true;
       NShowers++;
     }
 
     SegmentContainer protoTrack;
     protoTrack.push_back(*it);
 
     std::vector<int> layers;
     layers.push_back(1);
 
     // Try adding segment from other stations
     if (foundMatchingSegment(
             1, protoTrack, CSClist2F, usedCSClist2F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(2);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(3);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist4F, usedCSClist4F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(4);
     if (showeringBefore)
       NShowers++;
 
     // adding showering information
     if (layers.size() < 2 && !ShoweringSegments.empty()) {
       for (size_t i = 0; i < ShoweringSegments.size(); i++) {
         if (ShoweringLayers[i] <= layers[layers.size() - 1])
           continue;
         protoTrack.push_back(ShoweringSegments[i]);
         layers.push_back(ShoweringLayers[i]);
       }
     }
     ShoweringSegments.clear();
     ShoweringLayers.clear();
 
     TrajectorySeed thisSeed;
     if (layers.size() < 2) {
       thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
     } else {
       thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
     }
 
     // Add the seeds to master collection
     rawSeeds.push_back(thisSeed);
     etaOfSeed.push_back(eta_temp);
     phiOfSeed.push_back(phi_temp);
     nSegOnSeed.push_back(protoTrack.size());
 
     // mark this segment as used
     usedCSClist1F[index] = true;
   }
 
   // Loop over all possible ME2 segment to form seeds:
   index = -1;
   for (SegmentContainer::iterator it = CSClist2F.begin(); it != CSClist2F.end(); ++it) {
     index++;
 
     if (usedCSClist2F[index] == true)
       continue;
     if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
       continue;
 
     double dof = static_cast<double>((*it)->degreesOfFreedom());
     if (((*it)->chi2() / dof) > 20000.0)
       continue;
 
     // Global position of starting point for protoTrack
     GlobalPoint gp = (*it)->globalPosition();
     float eta_temp = gp.eta();
     float phi_temp = gp.phi();
     bool showeringBefore = false;
     NShowerSeg = 0;
     if (IdentifyShowering(CSClist2F, usedCSClist2F, eta_temp, phi_temp, 2, NShowerSeg))
       showeringBefore = true;
     int NShowers = 0;
     if (showeringBefore) {
       //    usedCSClist2F[index] = true;
       NShowers++;
     }
 
     SegmentContainer protoTrack;
     protoTrack.push_back(*it);
 
     std::vector<int> layers;
     layers.push_back(2);
 
     // Try adding segment from other stations
     if (foundMatchingSegment(
             1, protoTrack, CSClist3F, usedCSClist3F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(3);
     if (showeringBefore)
       NShowers++;
     if (foundMatchingSegment(
             1, protoTrack, CSClist4F, usedCSClist4F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(4);
     if (showeringBefore)
       NShowers++;
 
     // adding showering information
     if (layers.size() < 2 && !ShoweringSegments.empty()) {
       for (size_t i = 0; i < ShoweringSegments.size(); i++) {
         if (ShoweringLayers[i] <= layers[layers.size() - 1])
           continue;
         protoTrack.push_back(ShoweringSegments[i]);
         layers.push_back(ShoweringLayers[i]);
       }
     }
     ShoweringSegments.clear();
     ShoweringLayers.clear();
 
     TrajectorySeed thisSeed;
     if (layers.size() < 2) {
       thisSeed = muonSeedCreate_->createSeed(4, protoTrack, layers, NShowers, NShowerSeg);
     } else {
       thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
     }
 
     // Add the seeds to master collection
     rawSeeds.push_back(thisSeed);
     etaOfSeed.push_back(eta_temp);
     phiOfSeed.push_back(phi_temp);
     nSegOnSeed.push_back(protoTrack.size());
 
     // mark this segment as used
     usedCSClist2F[index] = true;
   }
 
   // Loop over all possible ME3 segment to form seeds:
   index = -1;
   for (SegmentContainer::iterator it = CSClist3F.begin(); it != CSClist3F.end(); ++it) {
     index++;
 
     if (usedCSClist3F[index] == true)
       continue;
     if (int((*it)->recHits().size()) < minCSCHitsPerSegment)
       continue;
 
     double dof = static_cast<double>((*it)->degreesOfFreedom());
     if (((*it)->chi2() / dof) > 20000.0)
       continue;
 
     // Global position of starting point for protoTrack
     GlobalPoint gp = (*it)->globalPosition();
     float eta_temp = gp.eta();
     float phi_temp = gp.phi();
     bool showeringBefore = false;
     NShowerSeg = 0;
     if (IdentifyShowering(CSClist3F, usedCSClist3F, eta_temp, phi_temp, 3, NShowerSeg))
       showeringBefore = true;
     int NShowers = 0;
     if (showeringBefore) {
       //   usedCSClist3F[index] = true;
       NShowers++;
     }
 
     SegmentContainer protoTrack;
     protoTrack.push_back(*it);
 
     std::vector<int> layers;
     layers.push_back(2);
 
     // Try adding segment from other stations
     if (foundMatchingSegment(
             1, protoTrack, CSClist4F, usedCSClist4F, eta_temp, phi_temp, layers[layers.size() - 1], showeringBefore))
       layers.push_back(4);
     if (showeringBefore)
       NShowers++;
 
     // adding showering information
     if (layers.size() < 2 && !ShoweringSegments.empty()) {
       for (size_t i = 0; i < ShoweringSegments.size(); i++) {
         if (ShoweringLayers[i] <= layers[layers.size() - 1])
           continue;
         protoTrack.push_back(ShoweringSegments[i]);
         layers.push_back(ShoweringLayers[i]);
       }
     }
     ShoweringSegments.clear();
     ShoweringLayers.clear();
 
     // mark this segment as used
     usedCSClist3F[index] = true;
 
     if (layers.size() < 2)
       continue;
 
     TrajectorySeed thisSeed = muonSeedCreate_->createSeed(1, protoTrack, layers, NShowers, NShowerSeg);
 
     // Add the seeds to master collection
     rawSeeds.push_back(thisSeed);
     etaOfSeed.push_back(eta_temp);
     phiOfSeed.push_back(phi_temp);
     nSegOnSeed.push_back(protoTrack.size());
   }
 
   /* *********************************************************************************************************************
    * Clean up raw seed collection and pass to master collection
    * *********************************************************************************************************************/
 
   if (debug)
     std::cout << "*** CLEAN UP " << std::endl;
   if (debug)
     std::cout << "Number of seeds BEFORE " << rawSeeds.size() << std::endl;
 
   int goodSeeds = 0;
 
   theSeeds = muonSeedClean_->seedCleaner(eventSetup, rawSeeds);
   goodSeeds = theSeeds.size();
 
   //std::cout << " === Before Cleaning : " << rawSeeds.size() <<std::endl;
   //std::cout << " => AFTER :" << goodSeeds << std::endl;
 
   if (debug)
     std::cout << "Number of seeds AFTER " << goodSeeds << std::endl;
 
   return goodSeeds;
 }

double MuonSeedBuilder::etaError	(	const GlobalPoint	gp,
		double	rErr
	)

private

calculate the eta error from global R error

Definition at line 1463 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().

                                                                   {
   double dHdTheta = 0.0;
   double dThetadR = 0.0;
   double etaErr = 1.0;
 
   if (gp.perp() != 0) {
     dHdTheta = (gp.mag() + gp.z()) / gp.perp();
     dThetadR = gp.z() / gp.perp2();
     etaErr = 0.25 * (dHdTheta * dThetadR) * (dHdTheta * dThetadR) * rErr;
   }
 
   return etaErr;
 }

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 1241 of file MuonSeedBuilder.cc.

References case1, case2, cuy::dh, HGC3DClusterGenMatchSelector_cfi::dR, PV3DBase< T, PVType, FrameType >::eta(), IdentifyShowering(), maxDeltaEtaCSC, maxDeltaEtaDT, maxDeltaEtaOverlap, maxDeltaPhiCSC, maxDeltaPhiDT, maxDeltaPhiOverlap, minCSCHitsPerSegment, minDTHitsPerSegment, muonSeedClean_, MuonSeedCleaner::NRecHitsFromSegment(), NShowerSeg, convertSQLiteXML::ok, PV3DBase< T, PVType, FrameType >::phi(), and mathSSE::sqrt().

Referenced by build().

                                                                   {
   bool ok = false;
   int scanlayer = (lastLayer < 0) ? (lastLayer - 1) : (lastLayer + 1);
 
   if (IdentifyShowering(segs, usedSeg, eta_last, phi_last, scanlayer, NShowerSeg)) {
     showeringBefore = true;
     return ok;
   }
 
   // Setup the searching cone-size
   // searching cone-size should changes with bending power
   double maxdEta;
   double maxdPhi;
   if (type == 1) {
     // CSC
     maxdEta = maxDeltaEtaCSC;
     if (lastLayer == 0 || lastLayer == 1) {
       if (fabs(eta_last) < 2.1) {
         maxdPhi = maxDeltaPhiCSC;
       } else {
         maxdPhi = 0.06;
       }
     } else if (lastLayer == 2) {
       maxdPhi = 0.5 * maxDeltaPhiCSC;
     } else {
       maxdPhi = 0.2 * maxDeltaPhiCSC;
     }
 
   } else if (type == 2) {
     // Overlap
     maxdEta = maxDeltaEtaOverlap;
     if (lastLayer == -1) {
       maxdPhi = maxDeltaPhiDT;
     } else {
       maxdPhi = maxDeltaPhiOverlap;
     }
 
   } else {
     // DT
     maxdEta = maxDeltaEtaDT;
     if (lastLayer == -1) {
       maxdPhi = maxDeltaPhiDT;
     } else if (lastLayer == -2) {
       maxdPhi = 0.8 * maxDeltaPhiDT;
     } else {
       maxdPhi = 0.4 * maxDeltaPhiDT;
     }
   }
 
   // if previous layer showers, limite the maxdPhi < 0.06
   if (showeringBefore && maxdPhi > 0.03)
     maxdPhi = 0.03;
   // reset the showering flag
   showeringBefore = false;
 
   // global phi/eta from previous segment
   float eta_temp = eta_last;
   float phi_temp = phi_last;
 
   // Index counter to keep track of element used in segs
   int index = -1;
   int best_match = index;
   float best_R = sqrt((maxdEta * maxdEta) + (maxdPhi * maxdPhi));
   float best_chi2 = 200;
   int best_dimension = 2;
   int best_nhits = minDTHitsPerSegment;
   if (type == 1)
     best_nhits = minCSCHitsPerSegment;
   // Loop over segments in other station (layer) and find candidate match
   for (SegmentContainer::iterator it = segs.begin(); it != segs.end(); ++it) {
     index++;
 
     // Not to get confused:  eta_last is from the previous layer.
     // This is only to find the best set of segments by comparing at the distance layer-by-layer
     GlobalPoint gp2 = (*it)->globalPosition();
     double dh = fabs(gp2.eta() - eta_temp);
     double df = fabs(gp2.phi() - phi_temp);
     double dR = sqrt((dh * dh) + (df * df));
 
     // dEta and dPhi should be within certain range
     bool case1 = (dh < maxdEta && df < maxdPhi) ? true : false;
     // for DT station 4 ; CSCSegment is always 4D
     bool case2 = (((*it)->dimension() != 4) && (dh < 0.5) && (df < maxdPhi)) ? true : false;
     if (!case1 && !case2)
       continue;
 
     int NRechits = muonSeedClean_->NRecHitsFromSegment(&*(*it));
 
     if (NRechits < best_nhits)
       continue;
     best_nhits = NRechits;
 
     // reject 2D segments if 4D segments are available
     if ((*it)->dimension() < best_dimension)
       continue;
     best_dimension = (*it)->dimension();
 
     // pick the segment with best chi2/dof within a fixed cone size
     if (dR > best_R)
       continue;
 
     // select smaller chi2/dof
     double dof = static_cast<double>((*it)->degreesOfFreedom());
     if ((*it)->chi2() / dof < 0.001 && NRechits < 6 && type == 1)
       continue;
     if ((*it)->chi2() / dof > best_chi2)
       continue;
     best_chi2 = (*it)->chi2() / dof;
     best_match = index;
     // propagate the eta and phi to next layer
     if ((*it)->dimension() != 4) {
       // Self assignment, is this a bug??
       // should this have been (phi/eta)_last = (phi/eta)_temp to make it reset?
       //phi_last = phi_last;
       //eta_last = eta_last;
     } else {
       phi_last = gp2.phi();
       eta_last = gp2.eta();
     }
   }
 
   if (best_match < 0)
     return ok;
 
   // Add best matching segment to protoTrack:
   index = -1;
   for (SegmentContainer::iterator it = segs.begin(); it != segs.end(); ++it) {
     index++;
     if (index != best_match)
       continue;
     protoTrack.push_back(*it);
     usedSeg[best_match] = true;
     ok = true;
   }
   return ok;
 }

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 1386 of file MuonSeedBuilder.cc.

References cuy::dh, HGC3DClusterGenMatchSelector_cfi::dR, 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().

                                                                  {
   bool showering = false;
 
   int nSeg = 0;
   int nRhits = 0;
   double nChi2 = 9999.;
   int theOrigin = -1;
   std::vector<int> badtag;
   int index = -1;
   double aveEta = 0.0;
   for (SegmentContainer::iterator it = segs.begin(); it != segs.end(); ++it) {
     index++;
     GlobalPoint gp = (*it)->globalPosition();
     double dh = gp.eta() - eta_last;
     double df = gp.phi() - phi_last;
     double dR = sqrt((dh * dh) + (df * df));
 
     double dof = static_cast<double>((*it)->degreesOfFreedom());
     double nX2 = (*it)->chi2() / dof;
 
     bool isDT = false;
     DetId geoId = (*it)->geographicalId();
     if (geoId.subdetId() == MuonSubdetId::DT)
       isDT = true;
 
     if (dR < 0.3) {
       nSeg++;
       badtag.push_back(index);
       aveEta += fabs(gp.eta());
       // pick up the best segment from showering chamber
       int rh = muonSeedClean_->NRecHitsFromSegment(&*(*it));
       if (rh < 6 && !isDT)
         continue;
       if (rh < 12 && isDT)
         continue;
       if (rh > nRhits) {
         nRhits = rh;
         if (nX2 > nChi2)
           continue;
         if (layer != 0 && layer != 1 && layer != -1) {
           theOrigin = index;
         }
       }
     }
   }
   aveEta = aveEta / static_cast<double>(nSeg);
   bool isME11A = (aveEta >= 2.1 && layer == 0) ? true : false;
   bool isME12 = (aveEta > 1.2 && aveEta <= 1.65 && layer == 1) ? true : false;
   bool isME11 = (aveEta > 1.65 && aveEta <= 2.1 && layer == 0) ? true : false;
   bool is1stLayer = (layer == -1 || layer == 0 || isME12 || isME11 || isME11A) ? true : false;
 
   NShoweringSegments += nSeg;
 
   if (nSeg > 3 && !isME11A)
     showering = true;
   if (nSeg > 6 && isME11A)
     showering = true;
 
   // if showering, flag all segments in order to skip this layer for pt estimation except 1st layer
   //std::cout<<" from Showering "<<std::endl;
   if (showering && !is1stLayer) {
     for (std::vector<int>::iterator it = badtag.begin(); it != badtag.end(); ++it) {
       usedSeg[*it] = true;
       if ((*it) != theOrigin)
         continue;
       ShoweringSegments.push_back(segs[*it]);
       ShoweringLayers.push_back(layer);
     }
   }
   return showering;
 }

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 50 of file MuonSeedBuilder.h.

References BField, and build().

Referenced by MuonSeedProducer::produce().

50 { BField = theField; }

MuonSeedBuilder::BField

const MagneticField * BField

Definition: MuonSeedBuilder.h:149

void MuonSeedBuilder::setGeometry ( const MuonDetLayerGeometry * lgeom )

inline

Cache pointer to geometry.

Definition at line 47 of file MuonSeedBuilder.h.

References muonLayers.

Referenced by MuonSeedProducer::produce().

47 { muonLayers = lgeom; }

MuonSeedBuilder::muonLayers

const MuonDetLayerGeometry * muonLayers

Definition: MuonSeedBuilder.h:146

Member Data Documentation

std::vector<int> MuonSeedBuilder::badSeedLayer

Definition at line 55 of file MuonSeedBuilder.h.

const MagneticField* MuonSeedBuilder::BField

private

Definition at line 149 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 109 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 115 of file MuonSeedBuilder.h.

Referenced by MuonSeedBuilder().

bool MuonSeedBuilder::enableDTMeasurement

private

Definition at line 112 of file MuonSeedBuilder.h.

Referenced by MuonSeedBuilder().

float MuonSeedBuilder::maxDeltaEtaCSC

private