MuonSeedCleaner Class Reference

#include <MuonSeedCleaner.h>

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

Public Member Functions
	MuonSeedCleaner (const edm::ParameterSet &, edm::ConsumesCollector &&)
	Constructor. More...
int	NRecHitsFromSegment (const TrackingRecHit &rhit)
int	NRecHitsFromSegment (MuonTransientTrackingRecHit *rhit)
std::vector< TrajectorySeed >	seedCleaner (const edm::EventSetup &eventSetup, std::vector< TrajectorySeed > &seeds)
	Cache pointer to geometry. More...
	~MuonSeedCleaner ()
	Destructor. More...

Public Attributes
std::vector< int >	badSeedLayer

Private Member Functions
TrajectorySeed	BiggerCone (std::vector< TrajectorySeed > &seeds)
	select the seed with bigger projection cone to next layer More...
TrajectorySeed	Chi2LengthSelection (std::vector< TrajectorySeed > &seeds)
	select seed by balance length and chi2 More...
std::vector< SeedContainer >	GroupSeeds (std::vector< TrajectorySeed > &seeds)
	group the seeds More...
TrajectorySeed	LeanHighMomentum (std::vector< TrajectorySeed > &seeds)
	select the highest momentum pt seed More...
SeedContainer	LengthFilter (std::vector< TrajectorySeed > &seeds)
bool	MomentumFilter (std::vector< TrajectorySeed > &seeds)
	filter out the bad pt seeds, if all are bad pt seeds then keep all More...
TrajectorySeed	MoreRecHits (std::vector< TrajectorySeed > &seeds)
	select the seed with more rechits More...
double	NChi2OfSegment (const TrackingRecHit &rhit)
	retrieve number of rechits& normalized chi2 of associated segments of a seed More...
unsigned int	OverlapSegments (const TrajectorySeed &seed1, const TrajectorySeed &seed2)
	check overlapping segment for seeds More...
SeedContainer	SeedCandidates (std::vector< TrajectorySeed > &seeds, bool good)
	pick the seeds w/ 1st layer information and w/ more than 1 segments More...
double	SeedChi2 (const TrajectorySeed &seed)
int	SeedLength (const TrajectorySeed &seed)
GlobalVector	SeedMomentum (const TrajectorySeed &seed)
	retrieve seed global momentum More...
GlobalPoint	SeedPosition (const TrajectorySeed &seed)
	retrieve seed global position More...

Private Attributes
bool	debug
std::vector< int >	ShoweringLayers
SegmentContainer	ShoweringSegments
MuonServiceProxy *	theService

Detailed Description

Algorith to clean duplicate seeds and select a right one

author: Shih-Chuan Kao - UCR

Definition at line 28 of file MuonSeedCleaner.h.

Member Typedef Documentation

BoolContainer

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

Definition at line 31 of file MuonSeedCleaner.h.

SegmentContainer

typedef MuonTransientTrackingRecHit::MuonRecHitContainer MuonSeedCleaner::SegmentContainer

Definition at line 30 of file MuonSeedCleaner.h.

Constructor & Destructor Documentation

MuonSeedCleaner()

MuonSeedCleaner::MuonSeedCleaner ( const edm::ParameterSet &  pset, edm::ConsumesCollector &&  iC  )

explicit

Constructor.

Definition at line 49 of file MuonSeedCleaner.cc.

References debug, eostools::move(), MuonServiceProxy_cff::MuonServiceProxy, muonDTDigis_cfi::pset, and theService.

                                                                                       {
  // Local Debug flag
  debug = pset.getParameter<bool>("DebugMuonSeed");

  // muon service
  edm::ParameterSet serviceParameters = pset.getParameter<edm::ParameterSet>("ServiceParameters");
  theService = new MuonServiceProxy(serviceParameters, std::move(iC));
}

~MuonSeedCleaner()

MuonSeedCleaner::~MuonSeedCleaner

(

)

Destructor.

Definition at line 61 of file MuonSeedCleaner.cc.

References theService.

                                  {
  if (theService)
    delete theService;
}

Member Function Documentation

BiggerCone()

TrajectorySeed MuonSeedCleaner::BiggerCone ( std::vector< TrajectorySeed > &  seeds )

private

select the seed with bigger projection cone to next layer

Definition at line 162 of file MuonSeedCleaner.cc.

References mps_fire::i, NRecHitsFromSegment(), diffTwoXMLs::r1, HLT_2024v11_cff::seeds, and mathSSE::sqrt().

Referenced by seedCleaner().

                                                                           {
  if (seeds.size() == 1)
    return seeds[0];

  float biggerProjErr = 9999.;
  int winner = 0;
  AlgebraicSymMatrix mat(5, 0);
  for (size_t i = 0; i < seeds.size(); i++) {
    auto r1 = seeds[i].recHits().begin();
    mat = r1->parametersError().similarityT(r1->projectionMatrix());

    int NRecHits = NRecHitsFromSegment(*r1);

    float ddx = mat[1][1];
    float ddy = mat[2][2];
    float dxx = mat[3][3];
    float dyy = mat[4][4];
    float projectErr = sqrt((ddx * 10000.) + (ddy * 10000.) + dxx + dyy);

    if (NRecHits < 5)
      continue;
    if (projectErr < biggerProjErr)
      continue;

    winner = static_cast<int>(i);
    biggerProjErr = projectErr;
  }
  TrajectorySeed theSeed = seeds[winner];
  seeds.erase(seeds.begin() + winner);
  return theSeed;
}

Chi2LengthSelection()

TrajectorySeed MuonSeedCleaner::Chi2LengthSelection ( std::vector< TrajectorySeed > &  seeds )

private

select seed by balance length and chi2

Definition at line 124 of file MuonSeedCleaner.cc.

References mps_fire::i, SeedChi2(), HLT_2024v11_cff::seeds, and bscTrigger_cfi::theHits.

Referenced by seedCleaner().

                                                                                    {
  if (seeds.size() == 1)
    return seeds[0];

  int winner = 0;
  int moreHits = 0;
  double bestChi2 = 99999.;
  for (size_t i = 0; i < seeds.size(); i++) {
    // 1. fill out the Nchi2 of segments of the seed
    //GlobalVector mom = SeedMomentum( seeds[i] ); // temporary use for debugging
    //double pt = sqrt( (mom.x()*mom.x()) + (mom.y()*mom.y()) );
    //std::cout<<" > SEED"<<i<<"  pt:"<<pt<< std::endl;

    double theChi2 = SeedChi2(seeds[i]);
    double dChi2 = fabs(1. - (theChi2 / bestChi2));
    int theHits = seeds[i].nHits();
    int dHits = theHits - moreHits;
    //std::cout<<" -----  "<<std::endl;

    // 2. better chi2
    if (theChi2 < bestChi2 && dChi2 > 0.05) {
      winner = static_cast<int>(i);
      bestChi2 = theChi2;
      moreHits = theHits;
    }
    // 3. if chi2 is not much better, pick more rechits one
    if (theChi2 >= bestChi2 && dChi2 < 0.05 && dHits > 0) {
      winner = static_cast<int>(i);
      bestChi2 = theChi2;
      moreHits = theHits;
    }
  }
  //std::cout<<" Winner is "<< winner <<std::endl;
  TrajectorySeed theSeed = seeds[winner];
  seeds.erase(seeds.begin() + winner);
  return theSeed;
}

GroupSeeds()

std::vector< SeedContainer > MuonSeedCleaner::GroupSeeds ( std::vector< TrajectorySeed > &  seeds )

private

group the seeds

Definition at line 323 of file MuonSeedCleaner.cc.

References hgcalPerformanceValidation::df, cuy::dh, HGC3DClusterGenMatchSelector_cfi::dR, PV3DBase< T, PVType, FrameType >::eta(), mps_fire::i, dqmiolumiharvest::j, lengthSorting(), nHits, OverlapSegments(), PV3DBase< T, PVType, FrameType >::phi(), ElectronSeedTrackRefFix_cfi::seedCollection, SeedPosition(), HLT_2024v11_cff::seeds, jetUpdater_cfi::sort, and mathSSE::sqrt().

Referenced by seedCleaner().

                                                                                     {
  std::vector<SeedContainer> seedCollection;
  seedCollection.clear();
  std::vector<TrajectorySeed> theGroup;
  std::vector<bool> usedSeed(seeds.size(), false);

  // categorize seeds by comparing overlapping segments or a certian eta-phi cone
  for (size_t i = 0; i < seeds.size(); i++) {
    if (usedSeed[i])
      continue;
    theGroup.push_back(seeds[i]);
    usedSeed[i] = true;

    GlobalPoint pos1 = SeedPosition(seeds[i]);

    for (size_t j = i + 1; j < seeds.size(); j++) {
      // 1.1 seeds with overlaaping segments will be grouped together
      unsigned int overlapping = OverlapSegments(seeds[i], seeds[j]);
      if (!usedSeed[j] && overlapping > 0) {
        // reject the identical seeds
        if (seeds[i].nHits() == overlapping && seeds[j].nHits() == overlapping) {
          usedSeed[j] = true;
          continue;
        }
        theGroup.push_back(seeds[j]);
        usedSeed[j] = true;
      }
      if (usedSeed[j])
        continue;

      // 1.2 seeds in a certain cone are grouped together
      GlobalPoint pos2 = SeedPosition(seeds[j]);
      double dh = pos1.eta() - pos2.eta();
      double df = pos1.phi() - pos2.phi();
      double dR = sqrt((dh * dh) + (df * df));

      if (dR > 0.3 && seeds[j].nHits() == 1)
        continue;
      if (dR > 0.2 && seeds[j].nHits() > 1)
        continue;
      theGroup.push_back(seeds[j]);
      usedSeed[j] = true;
    }
    sort(theGroup.begin(), theGroup.end(), lengthSorting);
    seedCollection.push_back(theGroup);
    //std::cout<<" group "<<seedCollection.size() <<" w/"<< theGroup.size() <<" seeds"<<std::endl;
    theGroup.clear();
  }
  return seedCollection;
}

LeanHighMomentum()

TrajectorySeed MuonSeedCleaner::LeanHighMomentum ( std::vector< TrajectorySeed > &  seeds )

private

select the highest momentum pt seed

Definition at line 194 of file MuonSeedCleaner.cc.

References mps_fire::i, DiDispStaMuonMonitor_cfi::pt, SeedMomentum(), HLT_2024v11_cff::seeds, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by seedCleaner().

                                                                                 {
  if (seeds.size() == 1)
    return seeds[0];

  double highestPt = 0.;
  int winner = 0;
  for (size_t i = 0; i < seeds.size(); i++) {
    GlobalVector mom = SeedMomentum(seeds[i]);
    double pt = sqrt((mom.x() * mom.x()) + (mom.y() * mom.y()));
    if (pt > highestPt) {
      winner = static_cast<int>(i);
      highestPt = pt;
    }
  }
  TrajectorySeed theSeed = seeds[winner];
  seeds.erase(seeds.begin() + winner);
  return theSeed;
}

LengthFilter()

SeedContainer MuonSeedCleaner::LengthFilter ( std::vector< TrajectorySeed > &  seeds )

private

pick the seed by better parameter error collect long seeds

Definition at line 243 of file MuonSeedCleaner.cc.

References mps_fire::i, and HLT_2024v11_cff::seeds.

                                                                            {
  SeedContainer longSeeds;
  int NSegs = 0;
  for (size_t i = 0; i < seeds.size(); i++) {
    int theLength = static_cast<int>(seeds[i].nHits());
    if (theLength > NSegs) {
      NSegs = theLength;
      longSeeds.clear();
      longSeeds.push_back(seeds[i]);
    } else if (theLength == NSegs) {
      longSeeds.push_back(seeds[i]);
    } else {
      continue;
    }
  }
  //std::cout<<" final Length :"<<NSegs<<std::endl;

  return longSeeds;
}

MomentumFilter()

bool MuonSeedCleaner::MomentumFilter ( std::vector< TrajectorySeed > &  seeds )

private

filter out the bad pt seeds, if all are bad pt seeds then keep all

Definition at line 263 of file MuonSeedCleaner.cc.

References mps_fire::i, DiDispStaMuonMonitor_cfi::pt, SeedMomentum(), HLT_2024v11_cff::seeds, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Referenced by seedCleaner().

                                                                     {
  bool findgoodMomentum = false;
  SeedContainer goodMomentumSeeds = seeds;
  seeds.clear();
  for (size_t i = 0; i < goodMomentumSeeds.size(); i++) {
    GlobalVector mom = SeedMomentum(goodMomentumSeeds[i]);
    double pt = sqrt((mom.x() * mom.x()) + (mom.y() * mom.y()));
    if (pt < 6. || pt > 2000.)
      continue;
    //if ( pt < 6. ) continue;
    //std::cout<<" passed momentum :"<< pt <<std::endl;
    seeds.push_back(goodMomentumSeeds[i]);
    findgoodMomentum = true;
  }
  if (seeds.empty())
    seeds = goodMomentumSeeds;

  return findgoodMomentum;
}

MoreRecHits()

TrajectorySeed MuonSeedCleaner::MoreRecHits ( std::vector< TrajectorySeed > &  seeds )

private

select the seed with more rechits

Definition at line 213 of file MuonSeedCleaner.cc.

References mps_fire::i, NRecHitsFromSegment(), diffTwoXMLs::r1, FastTrackerRecHitMaskProducer_cfi::recHits, SeedChi2(), HLT_2024v11_cff::seeds, and bscTrigger_cfi::theHits.

Referenced by seedCleaner().

                                                                            {
  if (seeds.size() == 1)
    return seeds[0];

  int winner = 0;
  int moreHits = 0;
  double betterChi2 = 99999.;
  for (size_t i = 0; i < seeds.size(); i++) {
    int theHits = 0;
    for (auto const& r1 : seeds[i].recHits()) {
      theHits += NRecHitsFromSegment(r1);
    }

    double theChi2 = SeedChi2(seeds[i]);

    if (theHits == moreHits && theChi2 < betterChi2) {
      betterChi2 = theChi2;
      winner = static_cast<int>(i);
    }
    if (theHits > moreHits) {
      moreHits = theHits;
      betterChi2 = theChi2;
      winner = static_cast<int>(i);
    }
  }
  TrajectorySeed theSeed = seeds[winner];
  seeds.erase(seeds.begin() + winner);
  return theSeed;
}

NChi2OfSegment()

double MuonSeedCleaner::NChi2OfSegment ( const TrackingRecHit &  rhit )

private

retrieve number of rechits& normalized chi2 of associated segments of a seed

Definition at line 489 of file MuonSeedCleaner.cc.

References TrackingRecHit::clone(), TrackingRecHit::geographicalId(), GlobalTrackingGeometry::idToDet(), MuonTransientTrackingRecHit::specificBuild(), theService, and MuonServiceProxy::trackingGeometry().

Referenced by SeedChi2().

                                                                 {
  double NChi2 = 999999.;
  const GeomDet* gdet = theService->trackingGeometry()->idToDet(rhit.geographicalId());
  MuonTransientTrackingRecHit::MuonRecHitPointer theSeg =
      MuonTransientTrackingRecHit::specificBuild(gdet, rhit.clone());

  double dof = static_cast<double>(theSeg->degreesOfFreedom());
  NChi2 = theSeg->chi2() / dof;
  //std::cout<<" Chi2 = "<< NChi2  <<" |" ;

  return NChi2;
}

NRecHitsFromSegment() [1/2]

int MuonSeedCleaner::NRecHitsFromSegment

(

const TrackingRecHit &

rhit

)

Definition at line 446 of file MuonSeedCleaner.cc.

References TrackingRecHit::clone(), MuonSubdetId::CSC, MuonSubdetId::DT, GeomDet::geographicalId(), TrackingRecHit::geographicalId(), GlobalTrackingGeometry::idToDet(), dqmiolumiharvest::j, findQualityFiles::size, MuonTransientTrackingRecHit::specificBuild(), theService, and MuonServiceProxy::trackingGeometry().

Referenced by BiggerCone(), MuonSeedBuilder::foundMatchingSegment(), MuonSeedBuilder::IdentifyShowering(), MoreRecHits(), and SeedLength().

                                                                   {
  int NRechits = 0;
  const GeomDet* gdet = theService->trackingGeometry()->idToDet(rhit.geographicalId());
  MuonTransientTrackingRecHit::MuonRecHitPointer theSeg =
      MuonTransientTrackingRecHit::specificBuild(gdet, rhit.clone());

  DetId geoId = gdet->geographicalId();
  if (geoId.subdetId() == MuonSubdetId::DT) {
    DTChamberId DT_Id(rhit.geographicalId());
    std::vector<TrackingRecHit*> DThits = theSeg->recHits();
    int dt1DHits = 0;
    for (size_t j = 0; j < DThits.size(); j++) {
      dt1DHits += (DThits[j]->recHits()).size();
    }
    NRechits = dt1DHits;
  }

  if (geoId.subdetId() == MuonSubdetId::CSC) {
    NRechits = (theSeg->recHits()).size();
  }
  return NRechits;
}

NRecHitsFromSegment() [2/2]

int MuonSeedCleaner::NRecHitsFromSegment

(

MuonTransientTrackingRecHit *

rhit

)

Definition at line 469 of file MuonSeedCleaner.cc.

References MuonSubdetId::CSC, MuonSubdetId::DT, TrackingRecHit::geographicalId(), dqmiolumiharvest::j, GenericTransientTrackingRecHit::recHits(), findQualityFiles::size, and DetId::subdetId().

                                                                          {
  int NRechits = 0;
  DetId geoId = rhit->geographicalId();
  if (geoId.subdetId() == MuonSubdetId::DT) {
    DTChamberId DT_Id(geoId);
    std::vector<TrackingRecHit*> DThits = rhit->recHits();
    int dt1DHits = 0;
    for (size_t j = 0; j < DThits.size(); j++) {
      dt1DHits += (DThits[j]->recHits()).size();
    }
    NRechits = dt1DHits;
    //std::cout<<" D_rh("<< dt1DHits  <<") " ;
  }
  if (geoId.subdetId() == MuonSubdetId::CSC) {
    NRechits = (rhit->recHits()).size();
    //std::cout<<" C_rh("<<(rhit->recHits()).size() <<") " ;
  }
  return NRechits;
}

OverlapSegments()

unsigned int MuonSeedCleaner::OverlapSegments ( const TrajectorySeed &  seed1, const TrajectorySeed &  seed2  )

private

check overlapping segment for seeds

Definition at line 374 of file MuonSeedCleaner.cc.

References PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, globals_cff::id1, globals_cff::id2, GlobalTrackingGeometry::idToDet(), diffTwoXMLs::r1, diffTwoXMLs::r2, TrajectorySeed::recHits(), mathSSE::sqrt(), theService, GeomDet::toGlobal(), MuonServiceProxy::trackingGeometry(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by GroupSeeds().

                                                                                                      {
  unsigned int overlapping = 0;
  for (auto const& r1 : seed1.recHits()) {
    DetId id1 = r1.geographicalId();
    const GeomDet* gdet1 = theService->trackingGeometry()->idToDet(id1);
    GlobalPoint gp1 = gdet1->toGlobal(r1.localPosition());

    for (auto const& r2 : seed2.recHits()) {
      DetId id2 = r2.geographicalId();
      if (id1 != id2)
        continue;

      const GeomDet* gdet2 = theService->trackingGeometry()->idToDet(id2);
      GlobalPoint gp2 = gdet2->toGlobal(r2.localPosition());

      double dx = gp1.x() - gp2.x();
      double dy = gp1.y() - gp2.y();
      double dz = gp1.z() - gp2.z();
      double dL = sqrt(dx * dx + dy * dy + dz * dz);

      if (dL < 1.)
        overlapping++;
    }
  }
  return overlapping;
}

SeedCandidates()

SeedContainer MuonSeedCleaner::SeedCandidates ( std::vector< TrajectorySeed > &  seeds, bool  good  )

private

pick the seeds w/ 1st layer information and w/ more than 1 segments

Definition at line 283 of file MuonSeedCleaner.cc.

References MuonSubdetId::CSC, MuonSubdetId::DT, GeomDet::geographicalId(), caHitNtupletGeneratorKernels::good, mps_fire::i, GlobalTrackingGeometry::idToDet(), nHits, diffTwoXMLs::r1, FastTrackerRecHitMaskProducer_cfi::recHits, HLT_2024v11_cff::seeds, CSCDetId::station(), DetId::subdetId(), theService, and MuonServiceProxy::trackingGeometry().

Referenced by seedCleaner().

                                                                                         {
  SeedContainer theCandidate;
  theCandidate.clear();

  bool longSeed = false;
  bool withFirstLayer = false;

  //std::cout<<"***** Seed Classification *****"<< seeds.size() <<std::endl;
  for (size_t i = 0; i < seeds.size(); i++) {
    if (seeds[i].nHits() > 1)
      longSeed = true;
    //std::cout<<"  Seed: "<<i<<" w/"<<seeds[i].nHits()<<" segs "<<std::endl;
    // looking for 1st layer segment
    for (auto const& r1 : seeds[i].recHits()) {
      const GeomDet* gdet = theService->trackingGeometry()->idToDet(r1.geographicalId());
      DetId geoId = gdet->geographicalId();

      if (geoId.subdetId() == MuonSubdetId::DT) {
        DTChamberId DT_Id(r1.geographicalId());
        //std::cout<<" ID:"<<DT_Id <<" pos:"<< r1->localPosition()  <<std::endl;
        if (DT_Id.station() != 1)
          continue;
        withFirstLayer = true;
      }
      if (geoId.subdetId() == MuonSubdetId::CSC) {
        CSCDetId CSC_Id = CSCDetId(r1.geographicalId());
        //std::cout<<" ID:"<<CSC_Id <<" pos:"<< r1->localPosition()  <<std::endl;
        if (CSC_Id.station() != 1)
          continue;
        withFirstLayer = true;
      }
    }
    bool goodseed = (longSeed && withFirstLayer) ? true : false;

    if (goodseed == good)
      theCandidate.push_back(seeds[i]);
  }
  return theCandidate;
}

SeedChi2()

double MuonSeedCleaner::SeedChi2 ( const TrajectorySeed &  seed )

private

Definition at line 401 of file MuonSeedCleaner.cc.

References NChi2OfSegment(), diffTwoXMLs::r1, and fileCollector::seed.

Referenced by Chi2LengthSelection(), and MoreRecHits().

                                                           {
  double theChi2 = 0.;
  for (auto const& r1 : seed.recHits()) {
    //std::cout<<"    segmet : "<<it <<std::endl;
    theChi2 += NChi2OfSegment(r1);
  }
  theChi2 = theChi2 / seed.nHits();

  //std::cout<<" final Length :"<<NSegs<<std::endl;
  return theChi2;
}

seedCleaner()

std::vector< TrajectorySeed > MuonSeedCleaner::seedCleaner	(	const edm::EventSetup &	eventSetup,
		std::vector< TrajectorySeed > &	seeds
	)

Cache pointer to geometry.

Cache pointer to Magnetic field cleaning the seeds

Definition at line 72 of file MuonSeedCleaner.cc.

References BiggerCone(), Chi2LengthSelection(), PVValHelper::eta, PV3DBase< T, PVType, FrameType >::eta(), options_cfi::eventSetup, GroupSeeds(), mps_fire::i, LeanHighMomentum(), MomentumFilter(), MoreRecHits(), SeedCandidates(), SeedPosition(), HLT_2024v11_cff::seeds, theService, and MuonServiceProxy::update().

Referenced by MuonSeedBuilder::build().

                                                                                           {
  theService->update(eventSetup);

  std::vector<TrajectorySeed> FinalSeeds;

  // group the seeds
  std::vector<SeedContainer> theCollection = GroupSeeds(seeds);

  // ckeck each group and pick the good one
  for (size_t i = 0; i < theCollection.size(); i++) {
    // separate seeds w/ more than 1 segments and w/ 1st layer segment information
    SeedContainer goodSeeds = SeedCandidates(theCollection[i], true);
    SeedContainer otherSeeds = SeedCandidates(theCollection[i], false);
    if (MomentumFilter(goodSeeds)) {
      //std::cout<<" == type1 "<<std::endl;
      TrajectorySeed bestSeed = Chi2LengthSelection(goodSeeds);
      FinalSeeds.push_back(bestSeed);

      GlobalPoint seedgp = SeedPosition(bestSeed);
      double eta = fabs(seedgp.eta());
      if (goodSeeds.size() > 2 && eta > 1.5) {
        TrajectorySeed anotherSeed = MoreRecHits(goodSeeds);
        FinalSeeds.push_back(anotherSeed);
      }
    } else if (MomentumFilter(otherSeeds)) {
      //std::cout<<" == type2 "<<std::endl;
      TrajectorySeed bestSeed = MoreRecHits(otherSeeds);
      FinalSeeds.push_back(bestSeed);

      GlobalPoint seedgp = SeedPosition(bestSeed);
      double eta = fabs(seedgp.eta());
      if (otherSeeds.size() > 2 && eta > 1.5) {
        TrajectorySeed anotherSeed = LeanHighMomentum(otherSeeds);
        FinalSeeds.push_back(anotherSeed);
      }
    } else {
      //std::cout<<" == type3 "<<std::endl;
      TrajectorySeed bestSeed = LeanHighMomentum(theCollection[i]);
      FinalSeeds.push_back(bestSeed);

      GlobalPoint seedgp = SeedPosition(bestSeed);
      double eta = fabs(seedgp.eta());
      if (theCollection.size() > 2 && eta > 1.5) {
        TrajectorySeed anotherSeed = BiggerCone(theCollection[i]);
        FinalSeeds.push_back(anotherSeed);
      }
    }
  }
  return FinalSeeds;
}

SeedLength()

int MuonSeedCleaner::SeedLength ( const TrajectorySeed &  seed )

private

Definition at line 413 of file MuonSeedCleaner.cc.

References NRecHitsFromSegment(), rpcPointValidation_cfi::recHit, fileCollector::seed, and bscTrigger_cfi::theHits.

                                                          {
  int theHits = 0;
  for (auto const& recHit : seed.recHits()) {
    //std::cout<<"    segmet : "<<it <<std::endl;
    theHits += NRecHitsFromSegment(recHit);
  }

  //std::cout<<" final Length :"<<NSegs<<std::endl;
  return theHits;
}

SeedMomentum()

GlobalVector MuonSeedCleaner::SeedMomentum ( const TrajectorySeed &  seed )

private

retrieve seed global momentum

Definition at line 435 of file MuonSeedCleaner.cc.

References PTrajectoryStateOnDet::detId(), TrajectoryStateOnSurface::globalMomentum(), GlobalTrackingGeometry::idToDet(), MuonServiceProxy::magneticField(), fileCollector::seed, theService, MuonServiceProxy::trackingGeometry(), and trajectoryStateTransform::transientState().

Referenced by LeanHighMomentum(), and MomentumFilter().

                                                                     {
  PTrajectoryStateOnDet pTSOD = seed.startingState();
  DetId SeedDetId(pTSOD.detId());
  const GeomDet* geoDet = theService->trackingGeometry()->idToDet(SeedDetId);
  TrajectoryStateOnSurface SeedTSOS =
      trajectoryStateTransform::transientState(pTSOD, &(geoDet->surface()), &*theService->magneticField());
  GlobalVector mom = SeedTSOS.globalMomentum();

  return mom;
}

SeedPosition()

GlobalPoint MuonSeedCleaner::SeedPosition ( const TrajectorySeed &  seed )

private

retrieve seed global position

Definition at line 424 of file MuonSeedCleaner.cc.

References PTrajectoryStateOnDet::detId(), TrajectoryStateOnSurface::globalPosition(), GlobalTrackingGeometry::idToDet(), MuonServiceProxy::magneticField(), fileCollector::seed, theService, MuonServiceProxy::trackingGeometry(), and trajectoryStateTransform::transientState().

Referenced by GroupSeeds(), and seedCleaner().

                                                                    {
  PTrajectoryStateOnDet pTSOD = seed.startingState();
  DetId SeedDetId(pTSOD.detId());
  const GeomDet* geoDet = theService->trackingGeometry()->idToDet(SeedDetId);
  TrajectoryStateOnSurface SeedTSOS =
      trajectoryStateTransform::transientState(pTSOD, &(geoDet->surface()), &*theService->magneticField());
  GlobalPoint pos = SeedTSOS.globalPosition();

  return pos;
}

Member Data Documentation

badSeedLayer

std::vector<int> MuonSeedCleaner::badSeedLayer

Definition at line 54 of file MuonSeedCleaner.h.

debug

bool MuonSeedCleaner::debug

private

Definition at line 93 of file MuonSeedCleaner.h.

Referenced by runTauIdMVA.TauIDEmbedder::load_againstElectronMVA6(), runTauIdMVA.TauIDEmbedder::loadMVA_WPs_run2_2017(), and MuonSeedCleaner().

ShoweringLayers

std::vector<int> MuonSeedCleaner::ShoweringLayers

private

Definition at line 97 of file MuonSeedCleaner.h.

ShoweringSegments

SegmentContainer MuonSeedCleaner::ShoweringSegments

private

Definition at line 96 of file MuonSeedCleaner.h.

theService

MuonServiceProxy* MuonSeedCleaner::theService

private

Definition at line 100 of file MuonSeedCleaner.h.

Referenced by MuonSeedCleaner(), NChi2OfSegment(), NRecHitsFromSegment(), OverlapSegments(), SeedCandidates(), seedCleaner(), SeedMomentum(), SeedPosition(), and ~MuonSeedCleaner().