GEMSegmentBuilder Class Reference

#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...

Private Attributes
std::unique_ptr< GEMSegmentAlgorithmBase >	algo
std::string	algoName
const GEMGeometry *	geom_
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 23 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.

                                                              : geom_(nullptr) {
  // Algo name
  algoName = ps.getParameter<std::string>("algo_name");
 
  edm::LogVerbatim("GEMSegmentBuilder") << "GEMSegmentBuilder algorithm name: " << algoName;
 
  // SegAlgo parameter set
  segAlgoPSet = ps.getParameter<edm::ParameterSet>("algo_pset");
 
  // Ask factory to build this algorithm, giving it appropriate ParameterSet
  algo = GEMSegmentBuilderPluginFactory::get()->create(algoName, segAlgoPSet);
}

References algo, algoName, get, edm::ParameterSet::getParameter(), segAlgoPSet, and AlCaHLTBitMon_QueryRunRegistry::string.

~GEMSegmentBuilder()

GEMSegmentBuilder::~GEMSegmentBuilder

(

)

Destructor.

Definition at line 24 of file GEMSegmentBuilder.cc.

{}

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 26 of file GEMSegmentBuilder.cc.

                                                                                          {
  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 = algo->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());
  }
}

References algo, relativeConstraints::chamber, GEMGeometry::etaPartition(), gemRecHits_cfi::gemRecHits, geom_, triggerObjects_cff::id, LogTrace, FastTrackerRecHitMaskProducer_cfi::recHits, and GEMGeometry::superChamber().

setGeometry()

void GEMSegmentBuilder::setGeometry

(

const GEMGeometry *

g

)

Cache pointer to geometry for current event

Definition at line 110 of file GEMSegmentBuilder.cc.

{ geom_ = geom; }

References relativeConstraints::geom, and geom_.

Member Data Documentation

algo

std::unique_ptr<GEMSegmentAlgorithmBase> GEMSegmentBuilder::algo

private

Definition at line 45 of file GEMSegmentBuilder.h.

Referenced by build(), and GEMSegmentBuilder().

algoName

std::string GEMSegmentBuilder::algoName

private

Definition at line 43 of file GEMSegmentBuilder.h.

Referenced by GEMSegmentBuilder().

geom_

const GEMGeometry* GEMSegmentBuilder::geom_

private

Definition at line 46 of file GEMSegmentBuilder.h.

Referenced by build(), and setGeometry().

segAlgoPSet

edm::ParameterSet GEMSegmentBuilder::segAlgoPSet

private

Definition at line 44 of file GEMSegmentBuilder.h.

Referenced by GEMSegmentBuilder().