#include <DTCombinatorialPatternReco4D.h>

Inheritance diagram for DTCombinatorialPatternReco4D:

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

	DTCombinatorialPatternReco4D (const edm::ParameterSet &pset)
	Constructor. More...

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

virtual void	setChamber (const DTChamberId &chId)

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

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

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

virtual bool	wants2DSegments ()

virtual	~DTCombinatorialPatternReco4D ()
	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 (const DTRecSegment4D *seg)
	Build a 4d segment with a zed component made by just one hits. More...

Private Attributes
bool	allDTRecHits

bool	applyT0corr

bool	computeT0corr

bool	debug

DTCombinatorialPatternReco *	the2DAlgo

std::string	theAlgoName

const DTChamber *	theChamber

edm::ESHandle< DTGeometry >	theDTGeometry

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 combinatorial 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 40 of file DTCombinatorialPatternReco4D.h.

Constructor & Destructor Documentation

DTCombinatorialPatternReco4D::DTCombinatorialPatternReco4D ( const edm::ParameterSet & pset )

Constructor.

Definition at line 32 of file DTCombinatorialPatternReco4D.cc.

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

                                                                                   :
   DTRecSegment4DBaseAlgo(pset), theAlgoName("DTCombinatorialPatternReco4D"){
 
     // 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);
 
     // 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 DTCombinatorialPatternReco(pset.getParameter<ParameterSet>("Reco2DAlgoConfig"));
   }

DTCombinatorialPatternReco4D::~DTCombinatorialPatternReco4D ( )

virtual

Destructor.

Definition at line 59 of file DTCombinatorialPatternReco4D.cc.

References the2DAlgo, and theUpdator.

                                                            {
   delete the2DAlgo;
   delete theUpdator;
 }

Member Function Documentation

virtual std::string DTCombinatorialPatternReco4D::algoName ( void ) const

inlinevirtual

Implements DTRecSegment4DBaseAlgo.

Definition at line 53 of file DTCombinatorialPatternReco4D.h.

References GeneralSetup::setup().

53 { return theAlgoName; }

DTCombinatorialPatternReco4D::theAlgoName

std::string theAlgoName

Definition: DTCombinatorialPatternReco4D.h:67

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

private

Definition at line 261 of file DTCombinatorialPatternReco4D.cc.

References DTCombinatorialPatternReco::buildSegments(), popcon2dropbox::copy(), gather_cfg::cout, debug, DTCombinatorialPatternReco::initHits(), DTGeometry::superLayer(), the2DAlgo, theDTGeometry, theHitsFromPhi1, and theHitsFromPhi2.

Referenced by reconstruct().

                                                                                                                                         {
 
   DTSuperLayerId slId;
 
   if(theHitsFromPhi1.size())
     slId = theHitsFromPhi1.front().wireId().superlayerId();
   else
     if(theHitsFromPhi2.size())
       slId = theHitsFromPhi2.front().wireId().superlayerId();
     else{
       if(debug) cout<<"DTCombinatorialPatternReco4D::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 > DTCombinatorialPatternReco4D::reconstruct ( )

virtual

Operations.

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

Implements DTRecSegment4DBaseAlgo.

Definition at line 127 of file DTCombinatorialPatternReco4D.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(), DTCombinatorialPatternReco::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 of the 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 of the 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.size()){
     hasZed = theSegments2DTheta.size() > 0;
     if (debug) cout << "There are " << theSegments2DTheta.size() << " Theta cand" << endl;
   } else {
     if (debug) cout << "No Theta SL" << endl;
   }
 
   // Now I want to build the concrete DTRecSegment4D.
   if(debug) cout<<"Building of the concrete DTRecSegment4D"<<endl;
   if (resultPhi.size()) {
     for (vector<DTSegmentCand*>::const_iterator phi=resultPhi.begin();
          phi!=resultPhi.end(); ++phi) {
 
       std::unique_ptr<DTChamberRecSegment2D> superPhi(**phi);
 
       theUpdator->update(superPhi.get(),0);
       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){
 
           if(debug) cout << "Theta: " << *zed << endl;
           // 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);
 
           if (debug) cout << "Created a 4D seg " << *newSeg << endl;
 
       theUpdator->update(newSeg,0,0);
           if (debug) cout << "     seg updated " <<  *newSeg << endl;
 
 
       if(!applyT0corr && computeT0corr) theUpdator->calculateT0corr(newSeg);
           if(applyT0corr) theUpdator->update(newSeg,true,0);
 
           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 " << *newSeg << endl;
 
        //update the segment with the t0 and possibly vdrift correction
         if(!applyT0corr && computeT0corr) theUpdator->calculateT0corr(newSeg);
     if(applyT0corr) theUpdator->update(newSeg,true,0);
 
         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){
         if(debug) cout << "Theta: " << *zed << endl;
 
         // 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 " << 
              *newSeg << endl;
 
         if(!applyT0corr && computeT0corr) theUpdator->calculateT0corr(newSeg);
     if(applyT0corr) theUpdator->update(newSeg,true,0);
 
         result.push_back(newSeg);
       }
     }
   }
   // finally delete the candidates!
   for (vector<DTSegmentCand*>::iterator phi=resultPhi.begin();
        phi!=resultPhi.end(); ++phi) delete *phi;
 
   return result;
 }

DTRecSegment4D * DTCombinatorialPatternReco4D::segmentSpecialZed ( const DTRecSegment4D * seg )

private

Build a 4d segment with a zed component made by just one hits.

Definition at line 290 of file DTCombinatorialPatternReco4D.cc.

References HiEvtPlane_cfi::chi2, DTRecSegment2D::chi2(), funct::cos(), DTRecSegment2D::covMatrix(), DTRecHit1D::digiTime(), dir, hfClusterShapes_cfi::hits, DTRecSegment4D::localDirection(), DTRecSegment2D::localDirection(), DTRecSegment4D::localPosition(), DTRecSegment2D::localPosition(), DTRecSegment2D::localPositionError(), DTRecHit1D::lrSide(), DTRecSegment4D::phiSegment(), mps_fire::result, DTRecSegment2D::specificRecHits(), DTSLRecSegment2D::superLayerId(), PV3DBase< T, PVType, FrameType >::theta(), DTRecHit1D::wireId(), PV3DBase< T, PVType, FrameType >::z(), and DTRecSegment4D::zSegment().

                                                                                         {
   // Get the zed projection
   //if (!seg->hasZed()) return seg;
   const DTSLRecSegment2D* zedSeg=seg->zSegment();
   std::vector<DTRecHit1D> hits = zedSeg->specificRecHits();
 
   // pick up a hit "in the middle", where the single hit will be put.
   int nHits=hits.size();
   DTRecHit1D middle=hits[static_cast<int>(nHits/2.)];
 
   // Need to extrapolate pos to the middle layer z
   LocalPoint posInSL = zedSeg->localPosition();
   LocalVector dirInSL = zedSeg->localDirection();
   LocalPoint posInMiddleLayer = posInSL+dirInSL*(-posInSL.z())/cos(dirInSL.theta());
 
   // create a hit with position and error as the Zed projection one's
   auto hit = std::make_unique<DTRecHit1D>(middle.wireId(),
                                           middle.lrSide(),
                                           middle.digiTime(),
                                           posInMiddleLayer,
                                           zedSeg->localPositionError());
 
   std::vector<DTRecHit1D> newHits(1,*hit);
 
   // create a new zed segment with that single hits, but same dir and pos
   LocalPoint pos(zedSeg->localPosition());
   LocalVector dir(zedSeg->localDirection());
   AlgebraicSymMatrix cov(zedSeg->covMatrix());
   double chi2(zedSeg->chi2());
   //cout << "zed " << *zedSeg << endl;
   auto newZed = std::make_unique<DTSLRecSegment2D>(zedSeg->superLayerId(),
                                                    pos,
                                                    dir,
                                                    cov,
                                                    chi2,
                                                    newHits);
   //cout << "newZed " << *newZed << endl;
 
   // create a 4d segment with the special zed
   DTRecSegment4D* result= new DTRecSegment4D(*seg->phiSegment(),
                                              *newZed,
                                              seg->localPosition(),
                                              seg->localDirection());
   // delete the input segment
   delete seg;
 
   // return it
   return result;
 }

void DTCombinatorialPatternReco4D::setChamber ( const DTChamberId & chId )

virtual

Implements DTRecSegment4DBaseAlgo.

Definition at line 70 of file DTCombinatorialPatternReco4D.cc.

References DTGeometry::chamber(), theChamber, and theDTGeometry.

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

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

virtual

Implements DTRecSegment4DBaseAlgo.

Definition at line 75 of file DTCombinatorialPatternReco4D.cc.

References allDTRecHits, gather_cfg::cout, debug, 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 DTCombinatorialPatternReco4D::setDTRecSegment2DContainer ( edm::Handle< DTRecSegment2DCollection > all2DSegments )

virtual

Implements DTRecSegment4DBaseAlgo.

Definition at line 106 of file DTCombinatorialPatternReco4D.cc.

References allDTRecHits, gather_cfg::cout, debug, 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 DTCombinatorialPatternReco4D::setES ( const edm::EventSetup & setup )

virtual

Implements DTRecSegment4DBaseAlgo.

Definition at line 64 of file DTCombinatorialPatternReco4D.cc.

References edm::EventSetup::get(), DTCombinatorialPatternReco::setES(), DTSegmentUpdator::setES(), the2DAlgo, theDTGeometry, and theUpdator.

                                                                {
   setup.get<MuonGeometryRecord>().get(theDTGeometry);
   the2DAlgo->setES(setup);
   theUpdator->setES(setup);
 }