#include <GEMSegmentBuilder.h>

Public Member Functions
void	build (const GEMRecHitCollection *rechits, GEMSegmentCollection &oc)

	GEMSegmentBuilder (const edm::ParameterSet &)

void	setGeometry (const GEMGeometry *g)

	~GEMSegmentBuilder ()
	Destructor. More...

Static Public Member Functions
static void	fillDescription (edm::ParameterSetDescription &descriptions)

Private Attributes
bool	enableGE0

bool	enableGE12

std::unique_ptr< GEMSegmentAlgorithmBase >	ge0Algo

std::string	ge0AlgoName

edm::ParameterSet	ge0AlgoPSet

const GEMGeometry *	geom_

std::unique_ptr< GEMSegmentAlgorithmBase >	segAlgo

std::string	segAlgoName

edm::ParameterSet	segAlgoPSet

Detailed Description

CSCSegmentBuilder Algorithm to build GEMSegment's from GEMRecHit collection by implementing a 'build' function required by GEMSegmentProducer.

Implementation notes:
Configured via the Producer's ParameterSet.
Presume this might become an abstract base class one day.

Author: Piet Verwilligen

Definition at line 24 of file GEMSegmentBuilder.h.

Constructor & Destructor Documentation

◆ GEMSegmentBuilder()

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

explicit

Configure the algorithm via ctor. Receives ParameterSet percolated down from EDProducer which owns this Builder.

Definition at line 12 of file GEMSegmentBuilder.cc.

References enableGE0, enableGE12, ge0Algo, ge0AlgoName, ge0AlgoPSet, get, edm::ParameterSet::getParameter(), segAlgo, segAlgoName, segAlgoPSet, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                               : geom_(nullptr) {
   // Segment building selection
   enableGE0 = ps.getParameter<bool>("enableGE0");
   enableGE12 = ps.getParameter<bool>("enableGE12");
 
   // Algo name
   segAlgoName = ps.getParameter<std::string>("algo_name");
   ge0AlgoName = ps.getParameter<std::string>("ge0_name");
 
   edm::LogVerbatim("GEMSegmentBuilder") << "GEMSegmentBuilder algorithm : ge0 name : " << ge0AlgoName
                                         << " name: " << segAlgoName;
 
   // SegAlgo parameter set
   segAlgoPSet = ps.getParameter<edm::ParameterSet>("algo_pset");
   ge0AlgoPSet = ps.getParameter<edm::ParameterSet>("ge0_pset");
 
   // Ask factory to build these algorithms, giving them the appropriate ParameterSets
   segAlgo = GEMSegmentBuilderPluginFactory::get()->create(segAlgoName, segAlgoPSet);
   ge0Algo = GEMSegmentBuilderPluginFactory::get()->create(ge0AlgoName, ge0AlgoPSet);
 }

◆ ~GEMSegmentBuilder()

GEMSegmentBuilder::~GEMSegmentBuilder ( )

Destructor.

Definition at line 32 of file GEMSegmentBuilder.cc.

32 {}

Member Function Documentation

◆ build()

void GEMSegmentBuilder::build	(	const GEMRecHitCollection *	rechits,
		GEMSegmentCollection &	oc
	)

Find rechits in each ensemble of 6 GEM layers, build GEMSegment's , and fill into output collection.

Definition at line 74 of file GEMSegmentBuilder.cc.

References relativeConstraints::chamber, enableGE0, enableGE12, GEMGeometry::etaPartition(), ge0Algo, me0TriggerPseudoDigis_cff::gemRecHits, geom_, EcalPhiSymFlatTableProducers_cfi::id, LogTrace, FastTrackerRecHitMaskProducer_cfi::recHits, segAlgo, and GEMGeometry::superChamber().

                                                                                           {
   edm::LogVerbatim("GEMSegmentBuilder") << "[GEMSegmentBuilder::build] Total number of rechits in this event: "
                                         << recHits->size();
 
   // Let's define the ensemble of GEM devices having the same region, chambers number (phi)
   // different eta partitions and different layers are allowed
 
   std::map<uint32_t, std::vector<const GEMRecHit*> > ensembleRH;
 
   // Loop on the GEM rechit and select the different GEM Ensemble
   for (GEMRecHitCollection::const_iterator it2 = recHits->begin(); it2 != recHits->end(); ++it2) {
     // GEM Ensemble is defined by assigning all the GEMDetIds of the same "superchamber"
     // (i.e. region same, chamber same) to the DetId of the first layer
 
     // here a reference GEMDetId is created: named "id"
     // - Ring 1 (no other rings available for GEM)
     // - Layer 1 = reference layer (effective layermask)
     // - Roll 0  = reference roll  (effective rollmask)
     // - Station == 1 (GE1/1) or == 2 (GE2/1)
     // this reference id serves to link all GEMEtaPartitions
     // and will also be used to determine the GEMSuperChamber
     // to which the GEMSegment is assigned (done inside GEMSegAlgoXX)
     GEMDetId id(it2->gemId().superChamberId());
     // save current GEMRecHit in vector associated to the reference id
     ensembleRH[id.rawId()].push_back(&(*it2));
   }
 
   // Loop on the entire map <ref id, vector of GEMRecHits>
   for (auto enIt = ensembleRH.begin(); enIt != ensembleRH.end(); ++enIt) {
     std::vector<const GEMRecHit*> gemRecHits;
     std::map<uint32_t, const GEMEtaPartition*> ens;
 
     // all detIds have been assigned to the to chamber
     const GEMSuperChamber* chamber = geom_->superChamber(enIt->first);
     for (auto rechit = enIt->second.begin(); rechit != enIt->second.end(); ++rechit) {
       gemRecHits.push_back(*rechit);
       ens[(*rechit)->gemId()] = geom_->etaPartition((*rechit)->gemId());
     }
 
 #ifdef EDM_ML_DEBUG  // have lines below only compiled when in debug mode
     LogTrace("GEMSegmentBuilder")
         << "[GEMSegmentBuilder::build] -----------------------------------------------------------------------------";
     LogTrace("GEMSegmentBuilder") << "[GEMSegmentBuilder::build] found " << gemRecHits.size()
                                   << " rechits in GEM Super Chamber " << chamber->id() << " ::";
     for (auto rh = gemRecHits.begin(); rh != gemRecHits.end(); ++rh) {
       auto gemid = (*rh)->gemId();
       // auto rhr = gemGeom->etaPartition(gemid);
       auto rhLP = (*rh)->localPosition();
       // auto rhGP = rhr->toGlobal(rhLP);
       // no sense to print local y because local y here is in the roll reference frame
       // in the roll reference frame the local y of a rechit is always the middle of the roll, and hence equal to 0.0
       LogTrace("GEMSegmentBuilder") << "[RecHit :: Loc x = " << std::showpos << std::setw(9)
                                     << rhLP.x() /*<<" Loc y = "<<std::showpos<<std::setw(9)<<rhLP.y()*/
                                     << " BX = " << (*rh)->BunchX() << " -- " << gemid.rawId() << " = " << gemid << " ]";
     }
 #endif
 
     GEMSegmentAlgorithmBase::GEMEnsemble ensemble(
         std::pair<const GEMSuperChamber*, std::map<uint32_t, const GEMEtaPartition*> >(chamber, ens));
 
 #ifdef EDM_ML_DEBUG  // have lines below only compiled when in debug mode
     LogTrace("GEMSegmentBuilder") << "[GEMSegmentBuilder::build] run the segment reconstruction algorithm now";
 #endif
 
     // given the superchamber select the appropriate algo... and run it
     std::vector<GEMSegment> segv;
     if (enableGE0 and chamber->id().station() == 0)
       segv = ge0Algo->run(ensemble, gemRecHits);
     else if (enableGE12)
       segv = segAlgo->run(ensemble, gemRecHits);
 #ifdef EDM_ML_DEBUG  // have lines below only compiled when in debug mode
     LogTrace("GEMSegmentBuilder") << "[GEMSegmentBuilder::build] found " << segv.size();
 #endif
 
     GEMDetId mid(enIt->first);
 
 #ifdef EDM_ML_DEBUG  // have lines below only compiled when in debug mode
     LogTrace("GEMSegmentBuilder") << "[GEMSegmentBuilder::build] found " << segv.size()
                                   << " segments in GEM Super Chamber " << mid;
     LogTrace("GEMSegmentBuilder")
         << "[GEMSegmentBuilder::build] -----------------------------------------------------------------------------";
 #endif
 
     // Add the segments to master collection
     oc.put(mid, segv.begin(), segv.end());
   }
 }

◆ fillDescription()

void GEMSegmentBuilder::fillDescription ( edm::ParameterSetDescription & descriptions )

static

Definition at line 34 of file GEMSegmentBuilder.cc.

References edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, edm::ParameterDescriptionNode::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by GEMSegmentProducer::fillDescriptions().

                                                                         {
   desc.add<bool>("enableGE0", true);
   desc.add<bool>("enableGE12", false);
   desc.add<std::string>("ge0_name", "GE0SegAlgoRU");
   desc.add<std::string>("algo_name", "GEMSegmentAlgorithm");
 
   edm::ParameterSetDescription ge0AlgoConfigDesc;
   ge0AlgoConfigDesc.add<bool>("allowWideSegments", true);
   ge0AlgoConfigDesc.add<bool>("doCollisions", true);
   ge0AlgoConfigDesc.add<double>("maxChi2Additional", 100);
   ge0AlgoConfigDesc.add<double>("maxChi2Prune", 50);
   ge0AlgoConfigDesc.add<double>("maxChi2GoodSeg", 50);
   ge0AlgoConfigDesc.add<double>("maxPhiSeeds", 0.001096605744)->setComment("Assuming 384 strips");
   ge0AlgoConfigDesc.add<double>("maxPhiAdditional", 0.001096605744)->setComment("Assuming 384 strips");
   ge0AlgoConfigDesc.add<double>("maxETASeeds", 0.1)->setComment("Assuming 8 eta partitions");
   ge0AlgoConfigDesc.add<double>("maxTOFDiff", 25);
   ge0AlgoConfigDesc.add<bool>("requireCentralBX", true)
       ->setComment("require that a majority of hits come from central BX");
   ge0AlgoConfigDesc.add<unsigned int>("minNumberOfHits", 4);
   ge0AlgoConfigDesc.add<unsigned int>("maxNumberOfHits", 300);
   ge0AlgoConfigDesc.add<unsigned int>("maxNumberOfHitsPerLayer", 100);
   desc.add<edm::ParameterSetDescription>("ge0_pset", ge0AlgoConfigDesc);
 
   edm::ParameterSetDescription recAlgoConfigDesc;
   recAlgoConfigDesc.addUntracked<bool>("GEMDebug", false);
   recAlgoConfigDesc.add<unsigned int>("minHitsPerSegment", 2);
   recAlgoConfigDesc.add<bool>("preClustering", true)
       ->setComment("False => all hits in chamber are given to the fitter");
   recAlgoConfigDesc.add<double>("dXclusBoxMax", 1)->setComment("Clstr Hit dPhi");
   recAlgoConfigDesc.add<double>("dYclusBoxMax", 5)->setComment("Clstr Hit dEta");
   recAlgoConfigDesc.add<bool>("preClusteringUseChaining", true)
       ->setComment("True ==> use Chaining() , False ==> use Clustering() Fnct");
   recAlgoConfigDesc.add<double>("dPhiChainBoxMax", .02)->setComment("Chain Hit dPhi");
   recAlgoConfigDesc.add<double>("dEtaChainBoxMax", .05)->setComment("Chain Hit dEta");
   recAlgoConfigDesc.add<int>("maxRecHitsInCluster", 4)->setComment("Does 4 make sense here?");
   recAlgoConfigDesc.add<bool>("clusterOnlySameBXRecHits", true)
       ->setComment("only working for (preClustering && preClusteringUseChaining)");
   desc.add<edm::ParameterSetDescription>("algo_pset", recAlgoConfigDesc);
 }