#include <DTMeantimerPatternReco4D.h>

Inheritance diagram for DTMeantimerPatternReco4D:

Public Member Functions
std::string	algoName () const override

	DTMeantimerPatternReco4D (const edm::ParameterSet &pset, edm::ConsumesCollector)
	Constructor. More...

edm::OwnVector< DTRecSegment4D >	reconstruct () override
	Operations. More...

void	setChamber (const DTChamberId &chId) override

void	setDTRecHit1DContainer (edm::Handle< DTRecHitCollection > all1DHits) override

void	setDTRecSegment2DContainer (edm::Handle< DTRecSegment2DCollection > all2DSegments) override

void	setES (const edm::EventSetup &setup) override

bool	wants2DSegments () override

	~DTMeantimerPatternReco4D () override
	Destructor. More...

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

virtual	~DTRecSegment4DBaseAlgo ()
	Destructor. More...

Private Member Functions
std::vector< DTSegmentCand * >	buildPhiSuperSegmentsCandidates (std::vector< std::shared_ptr< DTHitPairForFit >> &pairPhiOwned)

DTRecSegment4D *	segmentSpecialZed (DTRecSegment4D *seg)

Private Attributes
bool	allDTRecHits

bool	applyT0corr

bool	computeT0corr

bool	debug

DTMeantimerPatternReco *	the2DAlgo

std::string	theAlgoName

const DTChamber *	theChamber

edm::ESHandle< DTGeometry >	theDTGeometry

const edm::ESGetToken < DTGeometry, MuonGeometryRecord >	theDTGeometryToken

std::vector< DTRecHit1DPair >	theHitsFromPhi1

std::vector< DTRecHit1DPair >	theHitsFromPhi2

std::vector< DTRecHit1DPair >	theHitsFromTheta

std::vector< DTSLRecSegment2D >	theSegments2DTheta

DTSegmentUpdator *	theUpdator

Detailed Description

Algo for reconstructing 4d segment in DT using a Meantimer approach

Author: Stefano Lacaprara - INFN Legnaro stefa.nosp@m.no.l.nosp@m.acapr.nosp@m.ara@.nosp@m.pd.in.nosp@m.fn.i.nosp@m.t; Riccardo Bellan - INFN TO ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Definition at line 43 of file DTMeantimerPatternReco4D.h.

Constructor & Destructor Documentation

DTMeantimerPatternReco4D::DTMeantimerPatternReco4D	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector	cc
	)

Constructor.

Definition at line 33 of file DTMeantimerPatternReco4D.cc.

References allDTRecHits, applyT0corr, computeT0corr, debug, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), the2DAlgo, and theUpdator.

     : DTRecSegment4DBaseAlgo(pset), theAlgoName("DTMeantimerPatternReco4D"), theDTGeometryToken(cc.esConsumes()) {
   // debug parameter
   debug = pset.getUntrackedParameter<bool>("debug");
 
   //do you want the T0 correction?
   applyT0corr = pset.getParameter<bool>("performT0SegCorrection");
 
   computeT0corr = pset.existsAs<bool>("computeT0Seg") ? pset.getParameter<bool>("computeT0Seg") : true;
 
   // the updator
   theUpdator = new DTSegmentUpdator(pset, cc);
 
   // the input type.
   // If true the instructions in setDTRecSegment2DContainer will be schipped and the
   // theta segment will be recomputed from the 1D rechits
   // If false the theta segment will be taken from the Event. Caveat: in this case the
   // event must contain the 2D segments!
   allDTRecHits = pset.getParameter<bool>("AllDTRecHits");
 
   // Get the concrete 2D-segments reconstruction algo from the factory
   // For the 2D reco I use this reconstructor!
   the2DAlgo = new DTMeantimerPatternReco(pset.getParameter<ParameterSet>("Reco2DAlgoConfig"), cc);
 }

DTMeantimerPatternReco4D::~DTMeantimerPatternReco4D ( )

override

Destructor.

Definition at line 58 of file DTMeantimerPatternReco4D.cc.

References the2DAlgo, and theUpdator.

                                                     {
   delete the2DAlgo;
   delete theUpdator;
 }

Member Function Documentation

std::string DTMeantimerPatternReco4D::algoName ( ) const

inlineoverridevirtual

Implements DTRecSegment4DBaseAlgo.

Definition at line 54 of file DTMeantimerPatternReco4D.h.

References theAlgoName.

54 { return theAlgoName; }

DTMeantimerPatternReco4D::theAlgoName

std::string theAlgoName

Definition: DTMeantimerPatternReco4D.h:68

vector< DTSegmentCand * > DTMeantimerPatternReco4D::buildPhiSuperSegmentsCandidates ( std::vector< std::shared_ptr< DTHitPairForFit >> & pairPhiOwned )

private

Definition at line 257 of file DTMeantimerPatternReco4D.cc.

References DTMeantimerPatternReco::buildSegments(), filterCSVwithJSON::copy, gather_cfg::cout, debug, DTMeantimerPatternReco::initHits(), the2DAlgo, theDTGeometry, theHitsFromPhi1, and theHitsFromPhi2.

Referenced by reconstruct().

                                                           {
   DTSuperLayerId slId;
 
   if (!theHitsFromPhi1.empty())
     slId = theHitsFromPhi1.front().wireId().superlayerId();
   else if (!theHitsFromPhi2.empty())
     slId = theHitsFromPhi2.front().wireId().superlayerId();
   else {
     if (debug)
       cout << "DTMeantimerPatternReco4D::buildPhiSuperSegmentsCandidates: "
            << "No Hits in the two Phi SL" << endl;
     return vector<DTSegmentCand*>();
   }
 
   const DTSuperLayer* sl = theDTGeometry->superLayer(slId);
 
   vector<std::shared_ptr<DTHitPairForFit>> pairPhi1 = the2DAlgo->initHits(sl, theHitsFromPhi1);
   // same sl!! Since the fit will be in the sl phi 1!
   vector<std::shared_ptr<DTHitPairForFit>> pairPhi2 = the2DAlgo->initHits(sl, theHitsFromPhi2);
   // copy the pairPhi2 in the pairPhi1 vector
   copy(pairPhi2.begin(), pairPhi2.end(), back_inserter(pairPhi1));
 
   pairPhiOwned.swap(pairPhi1);
   // Build the segment candidate
   return the2DAlgo->buildSegments(sl, pairPhiOwned);
 }

OwnVector< DTRecSegment4D > DTMeantimerPatternReco4D::reconstruct ( )

overridevirtual

Operations.

4d segment: I have the pos along the wire => further update!

Implements DTRecSegment4DBaseAlgo.

Definition at line 120 of file DTMeantimerPatternReco4D.cc.

References allDTRecHits, applyT0corr, edm::OwnVector< T, P >::begin(), buildPhiSuperSegmentsCandidates(), DTSegmentUpdator::calculateT0corr(), computeT0corr, gather_cfg::cout, debug, edm::OwnVector< T, P >::end(), DTChamber::id(), phi, edm::OwnVector< T, P >::push_back(), DTMeantimerPatternReco::reconstruct(), mps_fire::result, DTChamber::superLayer(), the2DAlgo, theChamber, theHitsFromTheta, theSegments2DTheta, theUpdator, GeomDet::toGlobal(), GeomDet::toLocal(), DTSegmentUpdator::update(), and y.

                                                                 {
   OwnVector<DTRecSegment4D> result;
 
   if (debug) {
     cout << "Segments in " << theChamber->id() << endl;
     cout << "Reconstructing Phi segments" << endl;
   }
 
   vector<std::shared_ptr<DTHitPairForFit>> pairPhiOwned;
   vector<DTSegmentCand*> resultPhi = buildPhiSuperSegmentsCandidates(pairPhiOwned);
 
   if (debug)
     cout << "There are " << resultPhi.size() << " Phi cand" << endl;
 
   if (allDTRecHits) {
     // take the theta SL of this chamber
     const DTSuperLayer* sl = theChamber->superLayer(2);
     // sl points to 0 if the theta SL was not found
     if (sl) {
       // reconstruct the theta segments
       if (debug)
         cout << "Reconstructing Theta segments" << endl;
       OwnVector<DTSLRecSegment2D> thetaSegs = the2DAlgo->reconstruct(sl, theHitsFromTheta);
       vector<DTSLRecSegment2D> segments2DTheta(thetaSegs.begin(), thetaSegs.end());
       theSegments2DTheta = segments2DTheta;
     }
   }
 
   bool hasZed = false;
 
   // has this chamber the Z-superlayer?
   if (!theSegments2DTheta.empty()) {
     hasZed = !theSegments2DTheta.empty();
     if (debug)
       cout << "There are " << theSegments2DTheta.size() << " Theta cand" << endl;
   } else {
     if (debug)
       cout << "No Theta candidates." << endl;
   }
 
   // Now I want to build the concrete DTRecSegment4D.
   if (debug)
     cout << "Building the concrete DTRecSegment4D" << endl;
   if (!resultPhi.empty()) {
     for (vector<DTSegmentCand*>::const_iterator phi = resultPhi.begin(); phi != resultPhi.end(); ++phi) {
       std::unique_ptr<DTChamberRecSegment2D> superPhi(**phi);
 
       theUpdator->update(superPhi.get(), true);
       if (debug)
         cout << "superPhi: " << *superPhi << endl;
 
       if (hasZed) {
         // Create all the 4D-segment combining the Z view with the Phi one
         // loop over the Z segments
         for (vector<DTSLRecSegment2D>::const_iterator zed = theSegments2DTheta.begin(); zed != theSegments2DTheta.end();
              ++zed) {
           // Important!!
           DTSuperLayerId ZedSegSLId(zed->geographicalId().rawId());
 
           // Put the theta segment poistion in its 3D place.
           // note: (superPhi is in the CHAMBER local frame)
           const DTSuperLayer* zSL = theChamber->superLayer(ZedSegSLId);
 
           // FIXME: should rather extrapolate for Y!
           LocalPoint zPos(
               zed->localPosition().x(), (zSL->toLocal(theChamber->toGlobal(superPhi->localPosition()))).y(), 0.);
 
           const LocalPoint posZInCh = theChamber->toLocal(zSL->toGlobal(zPos));
           // FIXME: zed->localDirection() is in 2D. Should add the phi direction in the orthogonal plane as well!!
           const LocalVector dirZInCh = theChamber->toLocal(zSL->toGlobal(zed->localDirection()));
 
           DTRecSegment4D* newSeg = new DTRecSegment4D(*superPhi, *zed, posZInCh, dirZInCh);
 
           theUpdator->update(newSeg, false, true);
           if (debug)
             cout << "Created a 4D seg " << *newSeg << endl;
 
           //update the segment with the t0 and possibly vdrift correction
           if (!applyT0corr && computeT0corr)
             theUpdator->calculateT0corr(newSeg);
           if (applyT0corr)
             theUpdator->update(newSeg, true, true);
 
           result.push_back(newSeg);
         }
       } else {
         // Only phi
         DTRecSegment4D* newSeg = new DTRecSegment4D(*superPhi);
 
         if (debug)
           cout << "Created a 4D segment using only the 2D Phi segment" << endl;
 
         //update the segment with the t0 and possibly vdrift correction
         if (!applyT0corr && computeT0corr)
           theUpdator->calculateT0corr(newSeg);
         if (applyT0corr)
           theUpdator->update(newSeg, true, true);
 
         result.push_back(newSeg);
       }
     }
   } else {
     // DTRecSegment4D from zed projection only (unlikely, not so useful, but...)
     if (hasZed) {
       for (vector<DTSLRecSegment2D>::const_iterator zed = theSegments2DTheta.begin(); zed != theSegments2DTheta.end();
            ++zed) {
         // Important!!
         DTSuperLayerId ZedSegSLId(zed->geographicalId().rawId());
 
         const LocalPoint posZInCh =
             theChamber->toLocal(theChamber->superLayer(ZedSegSLId)->toGlobal(zed->localPosition()));
         const LocalVector dirZInCh =
             theChamber->toLocal(theChamber->superLayer(ZedSegSLId)->toGlobal(zed->localDirection()));
 
         DTRecSegment4D* newSeg = new DTRecSegment4D(*zed, posZInCh, dirZInCh);
         // <<
 
         if (debug)
           cout << "Created a 4D segment using only the 2D Theta segment" << endl;
 
         if (!applyT0corr && computeT0corr)
           theUpdator->calculateT0corr(newSeg);
         if (applyT0corr)
           theUpdator->update(newSeg, true, true);
 
         result.push_back(newSeg);
       }
     }
   }
   // finally delete the candidates!
   for (vector<DTSegmentCand*>::iterator phi = resultPhi.begin(); phi != resultPhi.end(); ++phi)
     delete *phi;
 
   return result;
 }

DTRecSegment4D* DTMeantimerPatternReco4D::segmentSpecialZed ( DTRecSegment4D * seg )

private

void DTMeantimerPatternReco4D::setChamber ( const DTChamberId & chId )

overridevirtual

Implements DTRecSegment4DBaseAlgo.

Definition at line 69 of file DTMeantimerPatternReco4D.cc.

References theChamber, and theDTGeometry.

                                                                  {
   // Set the chamber
   theChamber = theDTGeometry->chamber(chId);
 }

void DTMeantimerPatternReco4D::setDTRecHit1DContainer ( edm::Handle< DTRecHitCollection > all1DHits )

overridevirtual

Implements DTRecSegment4DBaseAlgo.

Definition at line 74 of file DTMeantimerPatternReco4D.cc.

References allDTRecHits, gather_cfg::cout, debug, DTSuperLayerId, DTChamber::id(), DTRangeMapAccessor::layersBySuperLayer(), theChamber, theHitsFromPhi1, theHitsFromPhi2, and theHitsFromTheta.

                                                                                           {
   theHitsFromPhi1.clear();
   theHitsFromPhi2.clear();
   theHitsFromTheta.clear();
 
   DTRecHitCollection::range rangeHitsFromPhi1 =
       all1DHits->get(DTRangeMapAccessor::layersBySuperLayer(DTSuperLayerId(theChamber->id(), 1)));
   DTRecHitCollection::range rangeHitsFromPhi2 =
       all1DHits->get(DTRangeMapAccessor::layersBySuperLayer(DTSuperLayerId(theChamber->id(), 3)));
 
   vector<DTRecHit1DPair> hitsFromPhi1(rangeHitsFromPhi1.first, rangeHitsFromPhi1.second);
   vector<DTRecHit1DPair> hitsFromPhi2(rangeHitsFromPhi2.first, rangeHitsFromPhi2.second);
   if (debug)
     cout << "Number of DTRecHit1DPair in the SL 1 (Phi 1): " << hitsFromPhi1.size() << endl
          << "Number of DTRecHit1DPair in the SL 3 (Phi 2): " << hitsFromPhi2.size() << endl;
 
   theHitsFromPhi1 = hitsFromPhi1;
   theHitsFromPhi2 = hitsFromPhi2;
 
   if (allDTRecHits) {
     DTRecHitCollection::range rangeHitsFromTheta =
         all1DHits->get(DTRangeMapAccessor::layersBySuperLayer(DTSuperLayerId(theChamber->id(), 2)));
 
     vector<DTRecHit1DPair> hitsFromTheta(rangeHitsFromTheta.first, rangeHitsFromTheta.second);
     if (debug)
       cout << "Number of DTRecHit1DPair in the SL 2 (Theta): " << hitsFromTheta.size() << endl;
     theHitsFromTheta = hitsFromTheta;
   }
 }

void DTMeantimerPatternReco4D::setDTRecSegment2DContainer ( edm::Handle< DTRecSegment2DCollection > all2DSegments )

overridevirtual

Implements DTRecSegment4DBaseAlgo.

Definition at line 104 of file DTMeantimerPatternReco4D.cc.

References allDTRecHits, gather_cfg::cout, debug, DTSuperLayerId, DTChamber::id(), theChamber, and theSegments2DTheta.

                                                                                                         {
   theSegments2DTheta.clear();
 
   if (!allDTRecHits) {
     //Extract the DTRecSegment2DCollection range for the theta SL
     DTRecSegment2DCollection::range rangeTheta = all2DSegments->get(DTSuperLayerId(theChamber->id(), 2));
 
     // Fill the DTRecSegment2D container for the theta SL
     vector<DTSLRecSegment2D> segments2DTheta(rangeTheta.first, rangeTheta.second);
 
     if (debug)
       cout << "Number of 2D-segments in the second SL (Theta): " << segments2DTheta.size() << endl;
     theSegments2DTheta = segments2DTheta;
   }
 }

void DTMeantimerPatternReco4D::setES ( const edm::EventSetup & setup )

overridevirtual

Implements DTRecSegment4DBaseAlgo.

Definition at line 63 of file DTMeantimerPatternReco4D.cc.

References edm::EventSetup::getHandle(), DTMeantimerPatternReco::setES(), DTSegmentUpdator::setES(), the2DAlgo, theDTGeometry, theDTGeometryToken, and theUpdator.

                                                             {
   theDTGeometry = setup.getHandle(theDTGeometryToken);
   the2DAlgo->setES(setup);
   theUpdator->setES(setup);
 }