#include <GE0SegAlgoRU.h>

Inheritance diagram for GE0SegAlgoRU:

Classes
struct	HitAndPosition

struct	SegmentParameters

Public Types
typedef std::vector< bool >	BoolContainer

typedef std::vector< HitAndPosition >	HitAndPositionContainer

typedef std::vector< const HitAndPosition * >	HitAndPositionPtrContainer

typedef std::vector< std::pair< float, HitAndPositionPtrContainer > >	SegmentByMetricContainer

Public Types inherited from GEMSegmentAlgorithmBase
typedef std::pair< const GEMSuperChamber , std::map< uint32_t, const GEMEtaPartition > >	GEMEnsemble

Public Member Functions
	GE0SegAlgoRU (const edm::ParameterSet &ps)
	Constructor. More...

std::vector< GEMSegment >	run (const GEMSuperChamber *chamber, const HitAndPositionContainer &rechits)

std::vector< GEMSegment >	run (const GEMEnsemble &ensemble, const std::vector< const GEMRecHit *> &rechits) override

	~GE0SegAlgoRU () override
	Destructor. More...

Public Member Functions inherited from GEMSegmentAlgorithmBase
	GEMSegmentAlgorithmBase (const edm::ParameterSet &)
	Constructor. More...

virtual	~GEMSegmentAlgorithmBase ()
	Destructor. More...

Private Member Functions
std::unique_ptr< MuonSegFit >	addHit (HitAndPositionPtrContainer &proto_segment, const HitAndPosition &aHit) const

void	addUniqueSegments (SegmentByMetricContainer &proto_segments, std::vector< GEMSegment > &segments, BoolContainer &used) const

bool	areHitsCloseInEta (const float maxETA, const bool beamConst, const GlobalPoint &h1, const GlobalPoint &h2) const

bool	areHitsCloseInGlobalPhi (const float maxPHI, const unsigned int nLayDisp, const GlobalPoint &h1, const GlobalPoint &h2) const

void	compareProtoSegment (std::unique_ptr< MuonSegFit > &current_fit, HitAndPositionPtrContainer &current_proto_segment, const HitAndPosition &new_hit) const

float	getHitSegChi2 (const std::unique_ptr< MuonSegFit > &fit, const GEMRecHit &hit) const

GlobalPoint	globalAtZ (const std::unique_ptr< MuonSegFit > &fit, float z) const

bool	hasHitOnLayer (const HitAndPositionPtrContainer &proto_segment, const unsigned int layer) const

void	increaseProtoSegment (const float maxChi2, std::unique_ptr< MuonSegFit > &current_fit, HitAndPositionPtrContainer &current_proto_segment, const HitAndPosition &new_hit) const

bool	isHitNearSegment (const float maxETA, const float maxPHI, const std::unique_ptr< MuonSegFit > &fit, const HitAndPositionPtrContainer &proto_segment, const HitAndPosition &h) const

void	lookForSegments (const SegmentParameters &params, const unsigned int n_seg_min, const HitAndPositionContainer &rechits, const std::vector< unsigned int > &recHits_per_layer, BoolContainer &used, std::vector< GEMSegment > &segments) const

std::unique_ptr< MuonSegFit >	makeFit (const HitAndPositionPtrContainer &proto_segment) const

void	pruneBadHits (const float maxChi2, HitAndPositionPtrContainer &proto_segment, std::unique_ptr< MuonSegFit > &fit, const unsigned int n_seg_min) const

void	tryAddingHitsToSegment (const float maxETA, const float maxPhi, const float maxChi2, std::unique_ptr< MuonSegFit > &current_fit, HitAndPositionPtrContainer &proto_segment, const BoolContainer &used, HitAndPositionContainer::const_iterator i1, HitAndPositionContainer::const_iterator i2) const

Private Attributes
bool	allowWideSegments

SegmentParameters	displacedParameters

bool	doCollisions

const std::string	myName

SegmentParameters	stdParameters

const GEMSuperChamber *	theChamber

SegmentParameters	wideParameters

Detailed Description

adapted from CSC to ME0 bt Marcello Maggi and ME0 to GE0 by Ian J. Watson

This is the original algorithm for building endcap muon track segments out of the rechit's in a GE0Chamber 'RU' = 'RUssia' = Road Usage

A GEMSegment is a RecSegment4D, and is built from GEMRecHit2D objects, each of which is a RecHit2DLocalPos.

This class is used by the GEMSegmentAlgorithm.
Alternative algorithms can be used for the segment building by writing classes like this, and then selecting which one is actually used via the GEMSegmentBuilder.

developed and implemented by Vladimir Palichik Vladi.nosp@m.mir..nosp@m.Paltc.nosp@m.hik@.nosp@m.cern..nosp@m.ch and Nikolay Voytishin nikol.nosp@m.ay.v.nosp@m.oytis.nosp@m.hin@.nosp@m.cern..nosp@m.ch

Definition at line 32 of file GE0SegAlgoRU.h.

Member Typedef Documentation

◆ BoolContainer

typedef std::vector<bool> GE0SegAlgoRU::BoolContainer

Definition at line 62 of file GE0SegAlgoRU.h.

◆ HitAndPositionContainer

typedef std::vector<HitAndPosition> GE0SegAlgoRU::HitAndPositionContainer

Definition at line 58 of file GE0SegAlgoRU.h.

◆ HitAndPositionPtrContainer

typedef std::vector<const HitAndPosition*> GE0SegAlgoRU::HitAndPositionPtrContainer

Definition at line 59 of file GE0SegAlgoRU.h.

◆ SegmentByMetricContainer

typedef std::vector<std::pair<float, HitAndPositionPtrContainer> > GE0SegAlgoRU::SegmentByMetricContainer

Definition at line 63 of file GE0SegAlgoRU.h.

Constructor & Destructor Documentation

◆ GE0SegAlgoRU()

GE0SegAlgoRU::GE0SegAlgoRU ( const edm::ParameterSet & ps )

explicit

Constructor.

Definition at line 26 of file GE0SegAlgoRU.cc.

                                                     : GEMSegmentAlgorithmBase(ps), myName("GE0SegAlgoRU") {
   allowWideSegments = ps.getParameter<bool>("allowWideSegments");
   doCollisions = ps.getParameter<bool>("doCollisions");
 
   stdParameters.maxChi2Additional = ps.getParameter<double>("maxChi2Additional");
   stdParameters.maxChi2Prune = ps.getParameter<double>("maxChi2Prune");
   stdParameters.maxChi2GoodSeg = ps.getParameter<double>("maxChi2GoodSeg");
   stdParameters.maxPhiSeeds = ps.getParameter<double>("maxPhiSeeds");
   stdParameters.maxPhiAdditional = ps.getParameter<double>("maxPhiAdditional");
   stdParameters.maxETASeeds = ps.getParameter<double>("maxETASeeds");
   stdParameters.requireCentralBX = ps.getParameter<bool>("requireCentralBX");
   stdParameters.minNumberOfHits = ps.getParameter<unsigned int>("minNumberOfHits");
   stdParameters.maxNumberOfHits = ps.getParameter<unsigned int>("maxNumberOfHits");
   stdParameters.maxNumberOfHitsPerLayer = ps.getParameter<unsigned int>("maxNumberOfHitsPerLayer");
   stdParameters.requireBeamConstr = true;
 
   wideParameters = stdParameters;
   wideParameters.maxChi2Prune *= 2;
   wideParameters.maxChi2GoodSeg *= 2;
   wideParameters.maxPhiSeeds *= 2;
   wideParameters.maxPhiAdditional *= 2;
   wideParameters.minNumberOfHits += 1;
 
   displacedParameters = stdParameters;
   displacedParameters.maxChi2Additional *= 2;
   displacedParameters.maxChi2Prune = 100;
   displacedParameters.maxChi2GoodSeg *= 5;
   displacedParameters.maxPhiSeeds *= 2;
   displacedParameters.maxPhiAdditional *= 2;
   displacedParameters.maxETASeeds *= 2;
   displacedParameters.requireBeamConstr = false;
 
   LogDebug("GE0SegAlgoRU") << myName << " has algorithm cuts set to: \n"
                            << "--------------------------------------------------------------------\n"
                            << "allowWideSegments   = " << allowWideSegments << "\n"
                            << "doCollisions        = " << doCollisions << "\n"
                            << "maxChi2Additional   = " << stdParameters.maxChi2Additional << "\n"
                            << "maxChi2Prune        = " << stdParameters.maxChi2Prune << "\n"
                            << "maxChi2GoodSeg      = " << stdParameters.maxChi2GoodSeg << "\n"
                            << "maxPhiSeeds         = " << stdParameters.maxPhiSeeds << "\n"
                            << "maxPhiAdditional    = " << stdParameters.maxPhiAdditional << "\n"
                            << "maxETASeeds         = " << stdParameters.maxETASeeds << "\n"
                            << std::endl;
 
   theChamber = nullptr;
 }

◆ ~GE0SegAlgoRU()

GE0SegAlgoRU::~GE0SegAlgoRU ( )

inlineoverride

Destructor.

Definition at line 68 of file GE0SegAlgoRU.h.

68 {};

Member Function Documentation

◆ addHit()

std::unique_ptr< MuonSegFit > GE0SegAlgoRU::addHit	(	HitAndPositionPtrContainer &	proto_segment,
		const HitAndPosition &	aHit
	)		const

private

Definition at line 429 of file GE0SegAlgoRU.cc.

References makeFit().

Referenced by compareProtoSegment(), increaseProtoSegment(), and lookForSegments().

                                                                                    {
   proto_segment.push_back(&aHit);
   // make a fit
   return makeFit(proto_segment);
 }

◆ addUniqueSegments()

void GE0SegAlgoRU::addUniqueSegments	(	SegmentByMetricContainer &	proto_segments,
		std::vector< GEMSegment > &	segments,
		BoolContainer &	used
	)		const

private

Definition at line 286 of file GE0SegAlgoRU.cc.

References a, b, GEMSuperChamber::computeDeltaPhi(), HLT_2023v12_cff::dPhi, h, createfilelist::int, makeFit(), jetUpdater_cfi::sort, groupFilesInBlocks::temp, and theChamber.

Referenced by lookForSegments().

                                                                 {
   std::sort(proto_segments.begin(),
             proto_segments.end(),
             [](const std::pair<float, HitAndPositionPtrContainer>& a,
                const std::pair<float, HitAndPositionPtrContainer>& b) { return a.first < b.first; });
 
   //Now add to the collect based on minChi2 marking the hits as used after
   std::vector<unsigned int> usedHits;
   for (auto& container : proto_segments) {
     HitAndPositionPtrContainer currentProtoSegment = container.second;
 
     //check to see if we already used thes hits this round
     bool alreadyFilled = false;
     for (const auto& h : currentProtoSegment) {
       for (unsigned int iOH = 0; iOH < usedHits.size(); ++iOH) {
         if (usedHits[iOH] != h->idx)
           continue;
         alreadyFilled = true;
         break;
       }
     }
     if (alreadyFilled)
       continue;
     for (const auto* h : currentProtoSegment) {
       usedHits.push_back(h->idx);
       used[h->idx] = true;
     }
 
     std::unique_ptr<MuonSegFit> current_fit = makeFit(currentProtoSegment);
 
     // Create an actual GEMSegment - retrieve all info from the fit
     // calculate the timing fron rec hits associated to the TrackingRecHits used
     // to fit the segment
     float averageBX = 0.;
     for (const auto* h : currentProtoSegment) {
       averageBX += h->rh->BunchX();
     }
     averageBX /= int(currentProtoSegment.size());
 
     std::sort(currentProtoSegment.begin(),
               currentProtoSegment.end(),
               [](const HitAndPosition* a, const HitAndPosition* b) { return a->layer < b->layer; });
 
     std::vector<const GEMRecHit*> bareRHs;
     bareRHs.reserve(currentProtoSegment.size());
     for (const auto* rh : currentProtoSegment)
       bareRHs.push_back(rh->rh);
     const float dPhi = theChamber->computeDeltaPhi(current_fit->intercept(), current_fit->localdir());
     GEMSegment temp(bareRHs,
                     current_fit->intercept(),
                     current_fit->localdir(),
                     current_fit->covarianceMatrix(),
                     current_fit->chi2(),
                     averageBX,
                     dPhi);
     segments.push_back(temp);
   }
 }

◆ areHitsCloseInEta()

bool GE0SegAlgoRU::areHitsCloseInEta	(	const float	maxETA,
		const bool	beamConst,
		const GlobalPoint &	h1,
		const GlobalPoint &	h2
	)		const

private

Definition at line 383 of file GE0SegAlgoRU.cc.

References funct::abs(), change_name::diff, PV3DBase< T, PVType, FrameType >::eta(), f, LogDebug, SiStripPI::max, and HLT_2023v12_cff::maxETA.

Referenced by lookForSegments().

                                                                   {
   float diff = std::abs(h1.eta() - h2.eta());
   LogDebug("GE0SegAlgoRU") << "[GE0SegAlgoRU::areHitsCloseInEta] gp1 = " << h1 << " in eta part = " << h1.eta()
                            << " and gp2 = " << h2 << " in eta part = " << h2.eta() << " ==> dEta = " << diff
                            << " ==> return " << (diff < 0.1) << std::endl;
   //temp for floating point comparision...maxEta is the difference between partitions, so x1.5 to take into account non-circle geom.
   return (diff < std::max(maxETA, 0.01f));
 }

◆ areHitsCloseInGlobalPhi()

bool GE0SegAlgoRU::areHitsCloseInGlobalPhi	(	const float	maxPHI,
		const unsigned int	nLayDisp,
		const GlobalPoint &	h1,
		const GlobalPoint &	h2
	)		const

private

Definition at line 395 of file GE0SegAlgoRU.cc.

References funct::abs(), PV3DBase< T, PVType, FrameType >::barePhi(), SiPixelRawToDigiRegional_cfi::deltaPhi, f, LogDebug, and SiStripPI::max.

Referenced by lookForSegments().

                                                                         {
   float dphi12 = deltaPhi(h1.barePhi(), h2.barePhi());
   LogDebug("GE0SegAlgoRU") << "[GE0SegAlgoRU::areHitsCloseInGlobalPhi] gp1 = " << h1 << " and gp2 = " << h2
                            << " ==> dPhi = " << dphi12 << " ==> return " << (std::abs(dphi12) < std::max(maxPHI, 0.02f))
                            << std::endl;
   return std::abs(dphi12) < std::max(maxPHI, float(float(nLayDisp) * 0.004));
 }

◆ compareProtoSegment()

void GE0SegAlgoRU::compareProtoSegment	(	std::unique_ptr< MuonSegFit > &	current_fit,
		HitAndPositionPtrContainer &	current_proto_segment,
		const HitAndPosition &	new_hit
	)		const

private

Definition at line 496 of file GE0SegAlgoRU.cc.

References funct::abs(), addHit(), GEMRecHit::BunchX(), nano_mu_digi_cff::float, h, GE0SegAlgoRU::HitAndPosition::layer, GE0SegAlgoRU::HitAndPosition::lp, eostools::move(), and GE0SegAlgoRU::HitAndPosition::rh.

Referenced by tryAddingHitsToSegment().

                                                                             {
   const HitAndPosition* old_hit = nullptr;
   HitAndPositionPtrContainer new_proto_segment = current_proto_segment;
 
   for (auto it = new_proto_segment.begin(); it != new_proto_segment.end();) {
     if ((*it)->layer == new_hit.layer) {
       old_hit = *it;
       it = new_proto_segment.erase(it);
     } else {
       ++it;
     }
   }
   if (old_hit == nullptr)
     return;
   auto new_fit = addHit(new_proto_segment, new_hit);
 
   //If on the same strip but different BX choose the closest
   bool useNew = false;
   if (old_hit->lp == new_hit.lp) {
     float avgbx = 0;
     for (const auto* h : current_proto_segment)
       if (old_hit != h)
         avgbx += h->rh->BunchX();
     avgbx /= float(current_proto_segment.size() - 1);
     if (std::abs(avgbx - new_hit.rh->BunchX()) < std::abs(avgbx - old_hit->rh->BunchX()))
       useNew = true;
   }  //otherwise base it on chi2
   else if (new_fit->chi2() < current_fit->chi2())
     useNew = true;
 
   if (useNew) {
     current_proto_segment = new_proto_segment;
     current_fit = std::move(new_fit);
   }
 }

◆ getHitSegChi2()

float GE0SegAlgoRU::getHitSegChi2	(	const std::unique_ptr< MuonSegFit > &	fit,
		const GEMRecHit &	hit
	)		const

private

Definition at line 473 of file GE0SegAlgoRU.cc.

Referenced by pruneBadHits().

                                                                                                   {
   const auto lp = hit.localPosition();
   const auto le = hit.localPositionError();
   const float du = fit->xdev(lp.x(), lp.z());
   const float dv = fit->ydev(lp.y(), lp.z());
 
   ROOT::Math::SMatrix<double, 2, 2, ROOT::Math::MatRepSym<double, 2> > IC;
   IC(0, 0) = le.xx();
   IC(1, 0) = le.xy();
   IC(1, 1) = le.yy();
 
   // Invert covariance matrix
   IC.Invert();
   return du * du * IC(0, 0) + 2. * du * dv * IC(0, 1) + dv * dv * IC(1, 1);
 }

◆ globalAtZ()

GlobalPoint GE0SegAlgoRU::globalAtZ	(	const std::unique_ptr< MuonSegFit > &	fit,
		float	z
	)		const

private

Definition at line 423 of file GE0SegAlgoRU.cc.

References theChamber, GeomDet::toGlobal(), x, y, and z.

Referenced by isHitNearSegment().

                                                                                        {
   float x = fit->xfit(z);
   float y = fit->yfit(z);
   return theChamber->toGlobal(LocalPoint(x, y, z));
 }

◆ hasHitOnLayer()

bool GE0SegAlgoRU::hasHitOnLayer	(	const HitAndPositionPtrContainer &	proto_segment,
		const unsigned int	layer
	)		const

private

Definition at line 489 of file GE0SegAlgoRU.cc.

References h, and nano_mu_digi_cff::layer.

Referenced by tryAddingHitsToSegment().

                                                                                                                 {
   for (const auto* h : proto_segment)
     if (h->layer == layer)
       return true;
   return false;
 }

◆ increaseProtoSegment()

void GE0SegAlgoRU::increaseProtoSegment	(	const float	maxChi2,
		std::unique_ptr< MuonSegFit > &	current_fit,
		HitAndPositionPtrContainer &	current_proto_segment,
		const HitAndPosition &	new_hit
	)		const

private

Definition at line 534 of file GE0SegAlgoRU.cc.

References addHit(), beam_dqm_sourceclient-live_cfg::maxChi2, and eostools::move().

Referenced by tryAddingHitsToSegment().

                                                                              {
   HitAndPositionPtrContainer new_proto_segment = current_proto_segment;
   auto new_fit = addHit(new_proto_segment, new_hit);
   if (new_fit->chi2() / new_fit->ndof() < maxChi2) {
     current_proto_segment = new_proto_segment;
     current_fit = std::move(new_fit);
   }
 }

◆ isHitNearSegment()

bool GE0SegAlgoRU::isHitNearSegment	(	const float	maxETA,
		const float	maxPHI,
		const std::unique_ptr< MuonSegFit > &	fit,
		const HitAndPositionPtrContainer &	proto_segment,
		const HitAndPosition &	h
	)		const

private

Definition at line 406 of file GE0SegAlgoRU.cc.

References funct::abs(), SiPixelRawToDigiRegional_cfi::deltaPhi, HLT_2023v12_cff::dPhi, f, globalAtZ(), h, SiStripPI::max, HLT_2023v12_cff::maxETA, and PV3DBase< T, PVType, FrameType >::phi().

Referenced by tryAddingHitsToSegment().

                                                                    {
   //Get average eta, based on the two seeds...asssumes that we have not started pruning yet!
   const float avgETA = (proto_segment[1]->gp.eta() + proto_segment[0]->gp.eta()) / 2.;
   if (std::abs(h.gp.eta() - avgETA) > std::max(maxETA, 0.01f))
     return false;
 
   //Now check the dPhi based on the segment fit
   GlobalPoint globIntercept = globalAtZ(fit, h.lp.z());
   float dPhi = deltaPhi(h.gp.barePhi(), globIntercept.phi());
   //check to see if it is inbetween the two rolls of the outer and inner hits
   return (std::abs(dPhi) < std::max(maxPHI, 0.001f));
 }

◆ lookForSegments()

void GE0SegAlgoRU::lookForSegments	(	const SegmentParameters &	params,
		const unsigned int	n_seg_min,
		const HitAndPositionContainer &	rechits,
		const std::vector< unsigned int > &	recHits_per_layer,
		BoolContainer &	used,
		std::vector< GEMSegment > &	segments
	)		const

private

Definition at line 200 of file GE0SegAlgoRU.cc.

References funct::abs(), addHit(), addUniqueSegments(), areHitsCloseInEta(), areHitsCloseInGlobalPhi(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, cuy::ib, LogDebug, submitPVValidationJobs::params, pruneBadHits(), HI_PhotonSkim_cff::rechits, and tryAddingHitsToSegment().

Referenced by run().

                                                                           {
   auto ib = rechits.begin();
   auto ie = rechits.end();
   std::vector<std::pair<float, HitAndPositionPtrContainer> > proto_segments;
   // the first hit is taken from the back
   for (auto i1 = ib; i1 != ie; ++i1) {
     const auto& h1 = *i1;
 
     //skip if rh is used and the layer tat has big rh multiplicity(>25RHs)
     if (used[h1.idx])
       continue;
     if (recHits_per_layer[h1.layer - 1] > params.maxNumberOfHitsPerLayer)
       continue;
 
     // the second hit from the front
     for (auto i2 = ie - 1; i2 != i1; --i2) {
       const auto& h2 = *i2;
 
       //skip if rh is used and the layer tat has big rh multiplicity(>25RHs)
       if (used[h2.idx])
         continue;
       if (recHits_per_layer[h2.layer - 1] > params.maxNumberOfHitsPerLayer)
         continue;
 
       //Stop if the distance between layers is not large enough
       if ((std::abs(int(h2.layer) - int(h1.layer)) + 1) < int(n_seg_min))
         break;
 
       if (!areHitsCloseInEta(params.maxETASeeds, params.requireBeamConstr, h1.gp, h2.gp))
         continue;
       if (!areHitsCloseInGlobalPhi(params.maxPhiSeeds, std::abs(int(h2.layer) - int(h1.layer)), h1.gp, h2.gp))
         continue;
 
       HitAndPositionPtrContainer current_proto_segment;
       std::unique_ptr<MuonSegFit> current_fit;
       current_fit = addHit(current_proto_segment, h1);
       current_fit = addHit(current_proto_segment, h2);
 
       tryAddingHitsToSegment(params.maxETASeeds,
                              params.maxPhiAdditional,
                              params.maxChi2Additional,
                              current_fit,
                              current_proto_segment,
                              used,
                              i1,
                              i2);
 
       if (current_proto_segment.size() > n_seg_min)
         pruneBadHits(params.maxChi2Prune, current_proto_segment, current_fit, n_seg_min);
 
       LogDebug("GE0SegAlgoRU") << "[GE0SegAlgoRU::lookForSegments] # of hits in segment "
                                << current_proto_segment.size() << " min # " << n_seg_min << " => "
                                << (current_proto_segment.size() >= n_seg_min) << " chi2/ndof "
                                << current_fit->chi2() / current_fit->ndof() << " => "
                                << (current_fit->chi2() / current_fit->ndof() < params.maxChi2GoodSeg) << std::endl;
 
       if (current_proto_segment.size() < n_seg_min)
         continue;
       const float current_metric = current_fit->chi2() / current_fit->ndof();
       if (current_metric > params.maxChi2GoodSeg)
         continue;
 
       if (params.requireCentralBX) {
         int nCentral = 0;
         int nNonCentral = 0;
         for (const auto* rh : current_proto_segment) {
           if (std::abs(rh->rh->BunchX()) < 2)
             nCentral++;
           else
             nNonCentral++;
         }
         if (nNonCentral >= nCentral)
           continue;
       }
 
       proto_segments.emplace_back(current_metric, current_proto_segment);
     }
   }
   addUniqueSegments(proto_segments, segments, used);
 }

◆ makeFit()

std::unique_ptr< MuonSegFit > GE0SegAlgoRU::makeFit ( const HitAndPositionPtrContainer & proto_segment ) const

private

Definition at line 436 of file GE0SegAlgoRU.cc.

References GEMRecHit::clone(), and GEMRecHit::setPosition().

Referenced by addHit(), addUniqueSegments(), and pruneBadHits().

                                                                                                      {
   // for GE0 we take the gemrechit from the proto_segment we transform into Tracking Rechits
   // the local rest frame is the GEMSuperChamber
   MuonSegFit::MuonRecHitContainer muonRecHits;
   for (const auto& rh : proto_segment) {
     GEMRecHit* newRH = rh->rh->clone();
     newRH->setPosition(rh->lp);
     MuonSegFit::MuonRecHitPtr trkRecHit(newRH);
     muonRecHits.push_back(trkRecHit);
   }
   auto currentFit = std::make_unique<MuonSegFit>(muonRecHits);
   currentFit->fit();
   return currentFit;
 }

◆ pruneBadHits()

void GE0SegAlgoRU::pruneBadHits	(	const float	maxChi2,
		HitAndPositionPtrContainer &	proto_segment,
		std::unique_ptr< MuonSegFit > &	fit,
		const unsigned int	n_seg_min
	)		const

private

Definition at line 451 of file GE0SegAlgoRU.cc.

References getHitSegChi2(), LogDebug, makeFit(), and beam_dqm_sourceclient-live_cfg::maxChi2.

Referenced by lookForSegments().

                                                                     {
   while (proto_segment.size() > n_seg_min && fit->chi2() / fit->ndof() > maxChi2) {
     float maxDev = -1;
     HitAndPositionPtrContainer::iterator worstHit;
     for (auto it = proto_segment.begin(); it != proto_segment.end(); ++it) {
       const float dev = getHitSegChi2(fit, *(*it)->rh);
       if (dev < maxDev)
         continue;
       maxDev = dev;
       worstHit = it;
     }
     LogDebug("GE0SegAlgoRU") << "[GE0SegAlgoRU::pruneBadHits] pruning one hit-> layer: " << (*worstHit)->layer
                              << " eta: " << (*worstHit)->gp.eta() << " phi: " << (*worstHit)->gp.phi()
                              << " old chi2/dof: " << fit->chi2() / fit->ndof() << std::endl;
     proto_segment.erase(worstHit);
     fit = makeFit(proto_segment);
   }
 }

◆ run() [1/2]

std::vector< GEMSegment > GE0SegAlgoRU::run	(	const GEMSuperChamber *	chamber,
		const HitAndPositionContainer &	rechits
	)

Here we must implement the algorithm

Definition at line 98 of file GE0SegAlgoRU.cc.

References allowWideSegments, relativeConstraints::chamber, displacedParameters, doCollisions, h, lookForSegments(), GE0SegAlgoRU::SegmentParameters::maxNumberOfHits, GE0SegAlgoRU::SegmentParameters::minNumberOfHits, GEMSuperChamber::nChambers(), HI_PhotonSkim_cff::rechits, stdParameters, and theChamber.

Referenced by run().

                                                                                                               {
 #ifdef EDM_ML_DEBUG  // have lines below only compiled when in debug mode
   GEMDetId chId(chamber->id());
   edm::LogVerbatim("GE0SegAlgoRU") << "[GEMSegmentAlgorithm::run] build segments in chamber " << chId
                                    << " which contains " << rechits.size() << " rechits";
   for (const auto& h : rechits) {
     auto ge0id = h.rh->gemId();
     auto rhLP = h.lp;
     edm::LogVerbatim("GE0SegAlgoRU") << "[RecHit :: Loc x = " << std::showpos << std::setw(9) << rhLP.x()
                                      << " Glb y = " << std::showpos << std::setw(9) << rhLP.y()
                                      << " Time = " << std::showpos << h.rh->BunchX() << " -- " << ge0id.rawId() << " = "
                                      << ge0id << " ]" << std::endl;
   }
 #endif
 
   if (rechits.size() < stdParameters.minNumberOfHits || rechits.size() > stdParameters.maxNumberOfHits) {
     return std::vector<GEMSegment>();
   }
 
   theChamber = chamber;
 
   std::vector<unsigned int> recHits_per_layer(theChamber->nChambers(), 0);
   for (const auto& rechit : rechits) {
     recHits_per_layer[rechit.layer - 1]++;
   }
 
   BoolContainer used(rechits.size(), false);
 
   // We have at least 2 hits. We intend to try all possible pairs of hits to start
   // segment building. 'All possible' means each hit lies on different layers in the chamber.
   // after all same size segs are build we get rid of the overcrossed segments using the chi2 criteria
   // the hits from the segs that are left are marked as used and are not added to segs in future iterations
   // the hits from 3p segs are marked as used separately in order to try to assamble them in longer segments
   // in case there is a second pass
 
   // Choose first hit (as close to IP as possible) h1 and second hit
   // (as far from IP as possible) h2 To do this we iterate over hits
   // in the chamber by layer - pick two layers.  Then we
   // iterate over hits within each of these layers and pick h1 and h2
   // these.  If they are 'close enough' we build an empty
   // segment.  Then try adding hits to this segment.
 
   std::vector<GEMSegment> segments;
 
   auto doStd = [&]() {
     for (unsigned int n_seg_min = 6u; n_seg_min >= stdParameters.minNumberOfHits; --n_seg_min)
       lookForSegments(stdParameters, n_seg_min, rechits, recHits_per_layer, used, segments);
   };
   auto doDisplaced = [&]() {
     for (unsigned int n_seg_min = 6u; n_seg_min >= displacedParameters.minNumberOfHits; --n_seg_min)
       lookForSegments(displacedParameters, n_seg_min, rechits, recHits_per_layer, used, segments);
   };
   // Not currently used
   // auto doWide = [&] () {
   //    for(unsigned int n_seg_min = 6u; n_seg_min >= wideParameters.minNumberOfHits; --n_seg_min)
   //        lookForSegments(wideParameters,n_seg_min,rechits,recHits_per_layer, used,segments);
   // };
   auto printSegments = [&] {
 #ifdef EDM_ML_DEBUG  // have lines below only compiled when in debug mode
     for (const auto& seg : segments) {
       GEMDetId chId(seg.gemDetId());
       const auto& rechits = seg.specificRecHits();
       edm::LogVerbatim("GE0SegAlgoRU") << "[GE0SegAlgoRU] segment in chamber " << chId << " which contains "
                                        << rechits.size() << " rechits and with specs: \n"
                                        << seg;
       for (const auto& rh : rechits) {
         auto ge0id = rh.gemId();
         edm::LogVerbatim("GE0SegAlgoRU") << "[RecHit :: Loc x = " << std::showpos << std::setw(9)
                                          << rh.localPosition().x() << " Loc y = " << std::showpos << std::setw(9)
                                          << rh.localPosition().y() << " Time = " << std::showpos << rh.BunchX()
                                          << " -- " << ge0id.rawId() << " = " << ge0id << " ]";
       }
     }
 #endif
   };
 
   //If we arent doing collisions, do a single iteration
   if (!doCollisions) {
     doDisplaced();
     printSegments();
     return segments;
   }
 
   //Iteration 1: STD processing
   doStd();
 
   if (false) {
     //How the CSC algorithm ~does iterations. for now not considering
     //displaced muons will not worry about it  later
     //Iteration 2a: If we don't allow wide segments simply do displaced
     // Or if we already found a segment simply skip to displaced
     if (!allowWideSegments || !segments.empty()) {
       doDisplaced();
       return segments;
     }
     //doWide();
     doDisplaced();
   }
   printSegments();
   return segments;
 }

◆ run() [2/2]

std::vector< GEMSegment > GE0SegAlgoRU::run	(	const GEMEnsemble &	ensemble,
		const std::vector< const GEMRecHit *> &	rechits
	)

overridevirtual

Run the algorithm = build the segments in this chamber

Implements GEMSegmentAlgorithmBase.

Definition at line 73 of file GE0SegAlgoRU.cc.

References glb, GE0SegAlgoRU::HitAndPosition::layer, LogDebug, position, HI_PhotonSkim_cff::rechits, run(), and jetUpdater_cfi::sort.

                                                                                                                {
   HitAndPositionContainer hitAndPositions;
   auto& superchamber = ensemble.first;
   for (const auto& rechit : rechits) {
     const GEMEtaPartition* part = ensemble.second.at(rechit->gemId().rawId());
     GlobalPoint glb = part->toGlobal(rechit->localPosition());
     LocalPoint nLoc = superchamber->toLocal(glb);
     hitAndPositions.emplace_back(&(*rechit), nLoc, glb, hitAndPositions.size());
   }
 
   LogDebug("GE0Segment|GE0") << "found " << hitAndPositions.size() << " rechits in superchamber " << superchamber->id();
   //sort by layer
   float z1 = superchamber->chamber(1)->position().z();
   float zlast = superchamber->chamber(superchamber->nChambers())->position().z();
   if (z1 < zlast)
     std::sort(hitAndPositions.begin(), hitAndPositions.end(), [](const HitAndPosition& h1, const HitAndPosition& h2) {
       return h1.layer < h2.layer;
     });
   else
     std::sort(hitAndPositions.begin(), hitAndPositions.end(), [](const HitAndPosition& h1, const HitAndPosition& h2) {
       return h1.layer > h2.layer;
     });
   return run(ensemble.first, hitAndPositions);
 }

◆ tryAddingHitsToSegment()

void GE0SegAlgoRU::tryAddingHitsToSegment	(	const float	maxETA,
		const float	maxPhi,
		const float	maxChi2,
		std::unique_ptr< MuonSegFit > &	current_fit,
		HitAndPositionPtrContainer &	proto_segment,
		const BoolContainer &	used,
		HitAndPositionContainer::const_iterator	i1,
		HitAndPositionContainer::const_iterator	i2
	)		const

private

Definition at line 347 of file GE0SegAlgoRU.cc.

References compareProtoSegment(), hasHitOnLayer(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, increaseProtoSegment(), isHitNearSegment(), beam_dqm_sourceclient-live_cfg::maxChi2, HLT_2023v12_cff::maxETA, and HLT_2023v12_cff::maxPhi.

Referenced by lookForSegments().

                                                                                           {
   // Iterate over the layers with hits in the chamber
   // Skip the layers containing the segment endpoints
   // Test each hit on the other layers to see if it is near the segment
   // If it is, see whether there is already a hit on the segment from the same layer
   //    - if so, and there are more than 2 hits on the segment, copy the segment,
   //      replace the old hit with the new hit. If the new segment chi2 is better
   //      then replace the original segment with the new one (by swap)
   //    - if not, copy the segment, add the hit. If the new chi2/dof is still satisfactory
   //      then replace the original segment with the new one (by swap)
 
   //Hits are ordered by layer, "i1" is the inner hit and i2 is the outer hit
   //so possible hits to add must be between these two iterators
   for (auto iH = i1 + 1; iH != i2; ++iH) {
     if (iH->layer == i1->layer)
       continue;
     if (iH->layer == i2->layer)
       break;
     if (used[iH->idx])
       continue;
     if (!isHitNearSegment(maxETA, maxPhi, current_fit, proto_segment, *iH))
       continue;
     if (hasHitOnLayer(proto_segment, iH->layer))
       compareProtoSegment(current_fit, proto_segment, *iH);
     else
       increaseProtoSegment(maxChi2, current_fit, proto_segment, *iH);
   }
 }

Member Data Documentation

◆ allowWideSegments

bool GE0SegAlgoRU::allowWideSegments

private

Definition at line 143 of file GE0SegAlgoRU.h.

Referenced by GE0SegAlgoRU(), and run().

◆ displacedParameters

SegmentParameters GE0SegAlgoRU::displacedParameters

private

Definition at line 146 of file GE0SegAlgoRU.h.

Referenced by GE0SegAlgoRU(), and run().

◆ doCollisions

bool GE0SegAlgoRU::doCollisions

private

Definition at line 142 of file GE0SegAlgoRU.h.

Referenced by GE0SegAlgoRU(), and run().

◆ myName

const std::string GE0SegAlgoRU::myName

private

Definition at line 141 of file GE0SegAlgoRU.h.

Referenced by GE0SegAlgoRU().

◆ stdParameters

SegmentParameters GE0SegAlgoRU::stdParameters

private

Definition at line 145 of file GE0SegAlgoRU.h.

Referenced by GE0SegAlgoRU(), and run().

◆ theChamber

const GEMSuperChamber* GE0SegAlgoRU::theChamber

private

Definition at line 150 of file GE0SegAlgoRU.h.

Referenced by addUniqueSegments(), GE0SegAlgoRU(), globalAtZ(), and run().

◆ wideParameters

SegmentParameters GE0SegAlgoRU::wideParameters

private

Definition at line 147 of file GE0SegAlgoRU.h.

Referenced by GE0SegAlgoRU().

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ BoolContainer

◆ HitAndPositionContainer

◆ HitAndPositionPtrContainer

◆ SegmentByMetricContainer

Constructor & Destructor Documentation

◆ GE0SegAlgoRU()

◆ ~GE0SegAlgoRU()

Member Function Documentation

◆ addHit()

◆ addUniqueSegments()

◆ areHitsCloseInEta()

◆ areHitsCloseInGlobalPhi()

◆ compareProtoSegment()

◆ getHitSegChi2()

◆ globalAtZ()

◆ hasHitOnLayer()

◆ increaseProtoSegment()

◆ isHitNearSegment()

◆ lookForSegments()

◆ makeFit()

◆ pruneBadHits()

◆ run() [1/2]

◆ run() [2/2]

◆ tryAddingHitsToSegment()

Member Data Documentation

◆ allowWideSegments

◆ displacedParameters

◆ doCollisions

◆ myName

◆ stdParameters

◆ theChamber

◆ wideParameters