#include <GEMCSCSegAlgoRR.h>

Inheritance diagram for GEMCSCSegAlgoRR:

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

std::vector< GEMCSCSegment >	run (const std::map< uint32_t, const CSCLayer * > &csclayermap, const std::map< uint32_t, const GEMEtaPartition * > &gemrollmap, const std::vector< const CSCSegment * > &cscsegments, const std::vector< const GEMRecHit * > &gemrechits) override

	~GEMCSCSegAlgoRR () override
	Destructor. More...

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

virtual	~GEMCSCSegmentAlgorithm ()
	Destructor. More...

Private Member Functions
std::vector< GEMCSCSegment >	buildSegments (const CSCSegment cscsegment, const std::vector< const TrackingRecHit > &rechits)

std::vector< const TrackingRecHit * >	chainHitsToSegm (const CSCSegment cscsegment, const std::vector< const GEMRecHit > &gemrechits)
	Utility functions. More...

Private Attributes
bool	debug
	Configuration parameters. More...

double	dPhiChainBoxMax

double	dRChainBoxMax

double	dThetaChainBoxMax

double	dXclusBoxMax

double	dYclusBoxMax

int	maxRecHitsInCluster

unsigned int	minHitsPerSegment

const std::string	myName
	Member variables. More...

bool	preClustering

bool	preClustering_useChaining

GEMCSCSegFit *	sfit_

std::map< uint32_t, const CSCLayer * >	theCSCLayers_

std::map< uint32_t, const GEMEtaPartition * >	theGEMEtaParts_

Detailed Description

This algorithm is very basic, there is no attempt to deal with ambiguities, such as noise etc. The GEMCSC track segment is built starting from a CSC segment and trying to match GEM rechits. The GEM rechits are searched inside a conigurable (eta,phi) window and associated to the segment. This collection of GEM rechits and CSC semgent is called the GEMCSC Ensemble.

Authors: Raffaella Radogna

Definition at line 25 of file GEMCSCSegAlgoRR.h.

Constructor & Destructor Documentation

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

explicit

Constructor.

Constructor

Definition at line 30 of file GEMCSCSegAlgoRR.cc.

References debug, dPhiChainBoxMax, dRChainBoxMax, dThetaChainBoxMax, dXclusBoxMax, dYclusBoxMax, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), maxRecHitsInCluster, minHitsPerSegment, preClustering, and preClustering_useChaining.

     : GEMCSCSegmentAlgorithm(ps), myName("GEMCSCSegAlgoRR"), sfit_(nullptr) {
   debug = ps.getUntrackedParameter<bool>("GEMCSCDebug");
   minHitsPerSegment = ps.getParameter<unsigned int>("minHitsPerSegment");
   preClustering = ps.getParameter<bool>("preClustering");
   dXclusBoxMax = ps.getParameter<double>("dXclusBoxMax");
   dYclusBoxMax = ps.getParameter<double>("dYclusBoxMax");
   preClustering_useChaining = ps.getParameter<bool>("preClusteringUseChaining");
   dPhiChainBoxMax = ps.getParameter<double>("dPhiChainBoxMax");
   dThetaChainBoxMax = ps.getParameter<double>("dThetaChainBoxMax");
   dRChainBoxMax = ps.getParameter<double>("dRChainBoxMax");
   maxRecHitsInCluster = ps.getParameter<int>("maxRecHitsInCluster");
 }

GEMCSCSegAlgoRR::~GEMCSCSegAlgoRR ( )

override

Destructor.

Destructor

Definition at line 47 of file GEMCSCSegAlgoRR.cc.

47 {}

Member Function Documentation

std::vector< GEMCSCSegment > GEMCSCSegAlgoRR::buildSegments	(	const CSCSegment *	cscsegment,
		const std::vector< const TrackingRecHit * > &	rechits
	)

private

Build the GEMCSCSegment.

This algorithm uses a Minimum Spanning Tree (ST) approach to build endcap muon track segments from the rechits in the 6 layers of a CSC and the 2 layers inside a GE1/1 GEM. Fit is implemented in GEMCSCSegFit.cc

Definition at line 279 of file GEMCSCSegAlgoRR.cc.

References CSCSegment::chi2(), GEMCSCSegFit::chi2(), GEMCSCSegFit::covarianceMatrix(), CSCSegment::cscDetId(), GEMCSCSegFit::fit(), MuonSubdetId::GEM, GEMCSCSegFit::intercept(), GEMCSCSegFit::localdir(), minHitsPerSegment, sfit_, CSCSegment::specificRecHits(), theCSCLayers_, theGEMEtaParts_, and createJobs::tmp.

Referenced by run().

                                                                                                            {
   std::vector<GEMCSCSegment> gemcscsegmentvector;
   std::vector<const GEMRecHit*> gemrechits;
 
   // Leave the function if the amount of rechits in the EnsembleHitContainer < min required
   if (rechits.size() < minHitsPerSegment) {
     return gemcscsegmentvector;
   }
 
   // Extract the GEMRecHits from the TrackingRecHit vector
   for (std::vector<const TrackingRecHit*>::const_iterator trhIt = rechits.begin(); trhIt != rechits.end(); ++trhIt) {
     if (DetId((*trhIt)->rawId()).subdetId() == MuonSubdetId::GEM) {
       gemrechits.push_back(((const GEMRecHit*)*trhIt));
     }
   }
 
   // The actual fit on all hits of the vector of the selected Tracking RecHits:
   delete sfit_;
   sfit_ = new GEMCSCSegFit(theCSCLayers_, theGEMEtaParts_, rechits);
   sfit_->fit();
 
   // obtain all information necessary to make the segment:
   LocalPoint protoIntercept = sfit_->intercept();
   LocalVector protoDirection = sfit_->localdir();
   AlgebraicSymMatrix protoErrors = sfit_->covarianceMatrix();
   double protoChi2 = sfit_->chi2();
 
   edm::LogVerbatim("GEMCSCSegAlgoRR")
       << "[GEMCSCSegAlgoRR::buildSegments] fit done, will now try to make GEMCSC Segment from CSC Segment in "
       << cscsegment->cscDetId() << " made of " << cscsegment->specificRecHits().size()
       << " rechits and with chi2 = " << cscsegment->chi2() << " and with " << gemrechits.size() << " GEM RecHits";
 
   // save all information inside GEMCSCSegment
   GEMCSCSegment tmp(cscsegment, gemrechits, protoIntercept, protoDirection, protoErrors, protoChi2);
 
   edm::LogVerbatim("GEMCSCSegAlgoRR") << "[GEMCSCSegAlgoRR::buildSegments] GEMCSC Segment made";
   gemcscsegmentvector.push_back(tmp);
   return gemcscsegmentvector;
 }

std::vector< const TrackingRecHit * > GEMCSCSegAlgoRR::chainHitsToSegm	(	const CSCSegment *	cscsegment,
		const std::vector< const GEMRecHit * > &	gemrechits
	)

private

Utility functions.

Search for GEMHits inside a Box around the position extrapolated from the CSC segment.

Chain hits :: make a TrackingRecHit vector containing both CSC and GEM rechits take the hits from the CSCSegment and add a clone of them take the hits from the GEM RecHit vector and check whether they are compatible with the CSC segment extrapolation to the GEM plane. If they are compatible, add these GEM rechits

Definition at line 154 of file GEMCSCSegAlgoRR.cc.

References CSCLayer::chamber(), GEMRecHit::clone(), dPhiChainBoxMax, dThetaChainBoxMax, CSCSegment::localDirection(), GEMRecHit::localPosition(), CSCSegment::localPosition(), PV3DBase< T, PVType, FrameType >::phi(), edm::second(), CSCSegment::specificRecHits(), theCSCLayers_, theGEMEtaParts_, GeomDet::toGlobal(), GeomDet::toLocal(), and PV3DBase< T, PVType, FrameType >::x().

Referenced by run().

                                                                                                                    {
   std::vector<const TrackingRecHit*> chainedRecHits;
 
   // working with layers makes it here a bit more difficult:
   // the CSC segment points to the chamber, which we cannot ask from the map
   // the CSC rechits point to the layers, from which we can ask the chamber
 
   auto segLP = cscsegment->localPosition();
   auto segLD = cscsegment->localDirection();
   auto cscrhs = cscsegment->specificRecHits();
 
   // Loop over the CSC Segment rechits
   // and save a copy in the chainedRecHits vector
   for (auto crh = cscrhs.begin(); crh != cscrhs.end(); crh++) {
     chainedRecHits.push_back(crh->clone());
   }
 
   // now ask the layer id of the first CSC rechit
   std::vector<const TrackingRecHit*>::const_iterator trhIt = chainedRecHits.begin();
   // make sure pointer is valid
   if (trhIt == chainedRecHits.end()) {
     edm::LogVerbatim("GEMCSCSegFit")
         << "[GEMCSCSegFit::chainHitsToSegm] CSC segment has zero rechits ... end function here";
     return chainedRecHits;
   }
   const CSCLayer* cscLayer = theCSCLayers_.find((*trhIt)->rawId())->second;
   // now ask the chamber id of the first CSC rechit
   if (!cscLayer) {
     edm::LogVerbatim("GEMCSCSegFit")
         << "[GEMCSCSegFit::chainHitsToSegm] CSC rechit ID was not found back in the CSCLayerMap ... end function here";
     return chainedRecHits;
   }
   const CSCChamber* cscChamber = cscLayer->chamber();
 
   // For non-empty GEM rechit vector
   if (!gemrechits.empty()) {
     float Dphi_min_l1 = 999;
     float Dphi_min_l2 = 999;
     float Dtheta_min_l1 = 999;
     float Dtheta_min_l2 = 999;
 
     std::vector<const GEMRecHit*>::const_iterator grhIt = gemrechits.begin();
 
     const GEMRecHit* gemrh_min_l1 = *grhIt;
     const GEMRecHit* gemrh_min_l2 = *grhIt;
 
     // Loop over GEM rechits from the EnsembleGEMHitContainer
     for (grhIt = gemrechits.begin(); grhIt != gemrechits.end(); ++grhIt) {
       // get GEM Rechit Local & Global Position
       auto rhLP = (*grhIt)->localPosition();
       const GEMEtaPartition* rhRef = theGEMEtaParts_.find((*grhIt)->gemId())->second;
       auto rhGP = rhRef->toGlobal(rhLP);
       // get GEM Rechit Local position w.r.t. the CSC Chamber
       // --> we are interessed in the z-coordinate
       auto rhLP_inSegmRef = cscChamber->toLocal(rhGP);
       // calculate the extrapolation of the CSC segment to the GEM plane (z-coord)
       // to get x- and y- coordinate
       float xe = 0.0, ye = 0.0, ze = 0.0;
       if (segLD.z() != 0) {
         xe = segLP.x() + segLD.x() * rhLP_inSegmRef.z() / segLD.z();
         ye = segLP.y() + segLD.y() * rhLP_inSegmRef.z() / segLD.z();
         ze = rhLP_inSegmRef.z();
       }
       // 3D extrapolated point in the GEM plane
       LocalPoint extrPoint(xe, ye, ze);
 
       // get GEM Rechit Global Position, but obtained from CSC Chamber
       // --> this should be the same as rhGP = rhRef->toGlobal(rhLP);
       auto rhGP_fromSegmRef = cscChamber->toGlobal(rhLP_inSegmRef);
       float phi_rh = rhGP_fromSegmRef.phi();
       float theta_rh = rhGP_fromSegmRef.theta();
       // get Extrapolat Global Position, also obtained from CSC Chamber
       auto extrPoinGP_fromSegmRef = cscChamber->toGlobal(extrPoint);
       float phi_ext = extrPoinGP_fromSegmRef.phi();
       float theta_ext = extrPoinGP_fromSegmRef.theta();
 
       // GEM 1st Layer :: Search for GEM Rechit with smallest Delta Eta and Delta Phi
       //                  and save it inside gemrh_min_l1
       if ((*grhIt)->gemId().layer() == 1) {
         float Dphi_l1 = fabs(phi_ext - phi_rh);
         float Dtheta_l1 = fabs(theta_ext - theta_rh);
         if (Dphi_l1 <= Dphi_min_l1) {
           Dphi_min_l1 = Dphi_l1;
           Dtheta_min_l1 = Dtheta_l1;
           gemrh_min_l1 = *grhIt;
         }
       }
       // GEM 2nd Layer :: Search for GEM Rechit with smallest Delta Eta and Delta Phi
       //                  and save it inside gemrh_min_l2
       if ((*grhIt)->gemId().layer() == 2) {
         float Dphi_l2 = fabs(phi_ext - phi_rh);
         float Dtheta_l2 = fabs(theta_ext - theta_rh);
         if (Dphi_l2 <= Dphi_min_l2) {
           Dphi_min_l2 = Dphi_l2;
           Dtheta_min_l2 = Dtheta_l2;
           gemrh_min_l2 = *grhIt;
         }
       }
 
     }  // end loop over GEM Rechits
 
     // Check whether GEM rechit with smallest delta eta and delta phi
     // w.r.t. the extrapolation of the CSC segment is within the
     // maxima given by the configuration of the algorithm
     bool phiRequirementOK_l1 = Dphi_min_l1 < dPhiChainBoxMax;
     bool thetaRequirementOK_l1 = Dtheta_min_l1 < dThetaChainBoxMax;
     if (phiRequirementOK_l1 && thetaRequirementOK_l1 && gemrh_min_l1 != nullptr) {
       chainedRecHits.push_back(gemrh_min_l1->clone());
     }
     bool phiRequirementOK_l2 = Dphi_min_l2 < dPhiChainBoxMax;
     bool thetaRequirementOK_l2 = Dtheta_min_l2 < dThetaChainBoxMax;
     if (phiRequirementOK_l2 && thetaRequirementOK_l2 && gemrh_min_l2 != nullptr) {
       chainedRecHits.push_back(gemrh_min_l2->clone());
     }
   }  // End check > 0 GEM rechits
 
   return chainedRecHits;
 }

std::vector< GEMCSCSegment > GEMCSCSegAlgoRR::run	(	const std::map< uint32_t, const CSCLayer * > &	csclayermap,
		const std::map< uint32_t, const GEMEtaPartition * > &	gemrollmap,
		const std::vector< const CSCSegment * > &	cscsegments,
		const std::vector< const GEMRecHit * > &	gemrechits
	)

overridevirtual

Build segments for all desired groups of hits

Run the algorithm

Implements GEMCSCSegmentAlgorithm.

Definition at line 52 of file GEMCSCSegAlgoRR.cc.

References buildSegments(), chainHitsToSegm(), AlCaHLTBitMon_QueryRunRegistry::string, theCSCLayers_, theGEMEtaParts_, and createJobs::tmp.

                                                                                                {
   // This function is called for each CSC Chamber (ME1/1) associated with a GEM chamber in which GEM Rechits were found
   // This means that the csc segment vector can contain more than one segment and that all combinations with the gemrechits have to be tried
 
   // assign the maps < detid, geometry object > to the class variables
   theCSCLayers_ = csclayermap;
   theGEMEtaParts_ = gemrollmap;
 
   // LogDebug info about reading of CSC Chamber map and GEM Eta Partition map
   edm::LogVerbatim("GEMCSCSegAlgoRR") << "[GEMCSCSegAlgoRR::run] cached the csclayermap and the gemrollmap";
 
   // --- LogDebug for CSC Layer map -----------------------------------------
   std::stringstream csclayermapss;
   csclayermapss << "[GEMCSCSegAlgoRR::run] :: csclayermap :: elements [" << std::endl;
   for (std::map<uint32_t, const CSCLayer*>::const_iterator mapIt = theCSCLayers_.begin(); mapIt != theCSCLayers_.end();
        ++mapIt) {
     csclayermapss << "[CSC DetId " << mapIt->first << " =" << CSCDetId(mapIt->first) << ", CSC Layer " << mapIt->second
                   << " =" << (mapIt->second)->id() << "]," << std::endl;
   }
   csclayermapss << "]" << std::endl;
   std::string csclayermapstr = csclayermapss.str();
   edm::LogVerbatim("GEMCSCSegAlgoRR") << csclayermapstr;
   // --- End LogDebug -------------------------------------------------------
 
   // --- LogDebug for GEM Eta Partition map ---------------------------------
   std::stringstream gemetapartmapss;
   gemetapartmapss << "[GEMCSCSegAlgoRR::run] :: gemetapartmap :: elements [" << std::endl;
   for (std::map<uint32_t, const GEMEtaPartition*>::const_iterator mapIt = theGEMEtaParts_.begin();
        mapIt != theGEMEtaParts_.end();
        ++mapIt) {
     gemetapartmapss << "[GEM DetId " << mapIt->first << " =" << GEMDetId(mapIt->first) << ", GEM EtaPart "
                     << mapIt->second << "]," << std::endl;
   }
   gemetapartmapss << "]" << std::endl;
   std::string gemetapartmapstr = gemetapartmapss.str();
   edm::LogVerbatim("GEMCSCSegAlgoRR") << gemetapartmapstr;
   // --- End LogDebug -------------------------------------------------------
 
   std::vector<GEMCSCSegment> segmentvectorfinal;
   std::vector<GEMCSCSegment> segmentvectorchamber;
   std::vector<GEMCSCSegment> segmentvectorfromfit;
   std::vector<const TrackingRecHit*> chainedRecHits;
 
   // From the GEMCSCSegmentBuilder we get
   // - a collection of CSC Segments belonging all to the same chamber
   // - a collection of GEM RecHits belonging to GEM Eta-Partitions close to this CSC
   //
   // Now we have to loop over all CSC Segments
   // and see to which CSC segments we can match the GEM rechits
   // if matching fails we will still keep those segments in the GEMCSC segment collection
   // but we will assign -1 to the matched parameter --> 2B implemented in the DataFormat
   // 1 for matched, 0 for no GEM chamber available and -1 for not matched
 
   // empty the temporary gemcsc segments vector
   // segmentvectortmp.clear();
 
   for (std::vector<const CSCSegment*>::const_iterator cscSegIt = cscsegments.begin(); cscSegIt != cscsegments.end();
        ++cscSegIt) {
     // chain hits :: make a vector of TrackingRecHits
     //               that contains the CSC and GEM rechits
     //               and that can be given to the fitter
     chainedRecHits = this->chainHitsToSegm(*cscSegIt, gemrechits);
 
     // if gemrechits are associated, run the buildSegments step
     if (chainedRecHits.size() > (*cscSegIt)->specificRecHits().size()) {
       segmentvectorfromfit = this->buildSegments(*cscSegIt, chainedRecHits);
     }
 
     // if no gemrechits are associated, wrap the existing CSCSegment in a GEMCSCSegment class
     else {
       std::vector<const GEMRecHit*> gemRecHits_noGEMrh;  // empty GEMRecHit vector
       GEMCSCSegment tmp(*cscSegIt,
                         gemRecHits_noGEMrh,
                         (*cscSegIt)->localPosition(),
                         (*cscSegIt)->localDirection(),
                         (*cscSegIt)->parametersError(),
                         (*cscSegIt)->chi2());
       segmentvectorfromfit.push_back(tmp);
     }
 
     segmentvectorchamber.insert(segmentvectorchamber.end(), segmentvectorfromfit.begin(), segmentvectorfromfit.end());
     segmentvectorfromfit.clear();
   }
 
   // add the found gemcsc segments to the collection of all gemcsc segments and return
   segmentvectorfinal.insert(segmentvectorfinal.end(), segmentvectorchamber.begin(), segmentvectorchamber.end());
   segmentvectorchamber.clear();
   edm::LogVerbatim("GEMCSCSegAlgoRR") << "[GEMCSCSegAlgoRR::run] GEMCSC Segments fitted or wrapped, size of vector = "
                                       << segmentvectorfinal.size();
   return segmentvectorfinal;
 }