#include <ME0SegmentBuilder.h>

Public Member Functions
void	build (const ME0RecHitCollection *rechits, ME0SegmentCollection &oc)

	ME0SegmentBuilder (const edm::ParameterSet &)

void	setGeometry (const ME0Geometry *g)

	~ME0SegmentBuilder ()
	Destructor. More...

Private Attributes
std::unique_ptr< ME0SegmentAlgorithmBase >	algo

const ME0Geometry *	geom_

Detailed Description

CSCSegmentBuilder Algorithm to build ME0Segment's from ME0RecHit collection by implementing a 'build' function required by ME0SegmentProducer.

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

Date: 2014/02/04 13:45:31

Revision: 1.1

Author: Marcello Maggi

Definition at line 25 of file ME0SegmentBuilder.h.

Constructor & Destructor Documentation

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

explicit

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

Definition at line 13 of file ME0SegmentBuilder.cc.

References algo, HIPAlignmentAlgorithm_cfi::algoName, timingPdfMaker::get, edm::ParameterSet::getParameter(), LogDebug, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                               : geom_(nullptr) {
   // Algo type (indexed)
   int chosenAlgo = ps.getParameter<int>("algo_type") - 1;
   // Find appropriate ParameterSets for each algo type
 
   std::vector<edm::ParameterSet> algoPSets = ps.getParameter<std::vector<edm::ParameterSet> >("algo_psets");
 
   edm::ParameterSet segAlgoPSet = algoPSets[chosenAlgo].getParameter<edm::ParameterSet>("algo_pset");
   std::string algoName = algoPSets[chosenAlgo].getParameter<std::string>("algo_name");
   LogDebug("ME0SegmentBuilder") << "ME0SegmentBuilder algorithm name: " << algoName;
 
   // Ask factory to build this algorithm, giving it appropriate ParameterSet
   algo = ME0SegmentBuilderPluginFactory::get()->create(algoName, segAlgoPSet);
 }

ME0SegmentBuilder::~ME0SegmentBuilder ( )

Destructor.

Definition at line 28 of file ME0SegmentBuilder.cc.

28 {}

Member Function Documentation

void ME0SegmentBuilder::build	(	const ME0RecHitCollection *	rechits,
		ME0SegmentCollection &	oc
	)

Find rechits in each ensemble of all ME0 layers, build ME0Segment's , and fill into output collection.

Definition at line 30 of file ME0SegmentBuilder.cc.

References algo, ME0Geometry::chamber(), relativeConstraints::chamber, ME0Geometry::etaPartition(), geom_, glb, ME0SegmentAlgorithmBase::HitAndPosition::layer, ME0Chamber::layers(), LogDebug, GeomDet::position(), GeomDet::toLocal(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                           {
   LogDebug("ME0SegmentBuilder") << "Total number of rechits in this event: " << recHits->size();
 
   std::map<ME0DetId, bool> foundChambers;
   for (ME0RecHitCollection::const_iterator it = recHits->begin(); it != recHits->end(); it++) {
     const auto chId = it->me0Id().chamberId();
     auto chIt = foundChambers.find(chId);
     if (chIt != foundChambers.end())
       continue;
     foundChambers[chId] = true;
     ME0SegmentAlgorithmBase::HitAndPositionContainer hitAndPositions;
     const ME0Chamber* chamber = geom_->chamber(chId);
     for (ME0RecHitCollection::const_iterator it2 = it; it2 != recHits->end(); it2++) {
       if (it2->me0Id().chamberId() != chId)
         continue;
 
       const auto* part = geom_->etaPartition(it2->me0Id());
       GlobalPoint glb = part->toGlobal(it2->localPosition());
       LocalPoint nLoc = chamber->toLocal(glb);
       hitAndPositions.emplace_back(&(*it2), nLoc, glb, hitAndPositions.size());
     }
 
     LogDebug("ME0Segment|ME0") << "found " << hitAndPositions.size() << " rechits in chamber " << chId;
     //sort by layer
     auto getLayer = [&](int iL) -> const ME0Layer* {  //function is broken in the geo currently
       for (auto layer : chamber->layers()) {
         if (layer->id().layer() == iL)
           return layer;
       }
       return nullptr;
     };
     float z1 = getLayer(1)->position().z();
     float z6 = getLayer(6)->position().z();
     if (z1 < z6)
       std::sort(hitAndPositions.begin(),
                 hitAndPositions.end(),
                 [](const ME0SegmentAlgorithmBase::HitAndPosition& h1,
                    const ME0SegmentAlgorithmBase::HitAndPosition& h2) { return h1.layer < h2.layer; });
     else
       std::sort(hitAndPositions.begin(),
                 hitAndPositions.end(),
                 [](const ME0SegmentAlgorithmBase::HitAndPosition& h1,
                    const ME0SegmentAlgorithmBase::HitAndPosition& h2) { return h1.layer > h2.layer; });
 
     // given the chamber select the appropriate algo... and run it
     std::vector<ME0Segment> segv = algo->run(chamber, hitAndPositions);
 
     LogDebug("ME0Segment|ME0") << "found " << segv.size() << " segments in chamber " << chId;
 
     // Add the segments to master collection
     if (!segv.empty())
       oc.put(chId, segv.begin(), segv.end());
   }
 }