Inheritance diagram for FastTrackerRecHitMatcher:

Public Member Functions
	FastTrackerRecHitMatcher (const edm::ParameterSet &)

	~FastTrackerRecHitMatcher () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Types
typedef std::pair< LocalPoint, LocalPoint >	StripPosition

Private Member Functions
const FastSingleTrackerRecHit *	_cast2Single (const FastTrackerRecHit *recHit) const

std::unique_ptr< FastTrackerRecHit >	match (const FastSingleTrackerRecHit monoRH, const FastSingleTrackerRecHit stereoRH, const GluedGeomDet *gluedDet, LocalVector &trackdirection, bool stereLayerFirst) const

void	produce (edm::Event &, const edm::EventSetup &) override

StripPosition	project (const GeomDetUnit det, const GluedGeomDet glueddet, const StripPosition &strip, const LocalVector &trackdirection) const

std::unique_ptr< FastTrackerRecHit >	projectOnly (const FastSingleTrackerRecHit originalRH, const GeomDet monoDet, const GluedGeomDet *gluedDet, LocalVector &ldir) const

Private Attributes
edm::EDGetTokenT< FastTrackerRecHitRefCollection >	simHit2RecHitMapToken

edm::EDGetTokenT< edm::PSimHitContainer >	simHitsToken

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	trackerGeometryESToken

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 30 of file FastTrackerRecHitMatcher.cc.

Member Typedef Documentation

◆ StripPosition

typedef std::pair<LocalPoint, LocalPoint> FastTrackerRecHitMatcher::StripPosition

private

Definition at line 40 of file FastTrackerRecHitMatcher.cc.

Constructor & Destructor Documentation

◆ FastTrackerRecHitMatcher()

FastTrackerRecHitMatcher::FastTrackerRecHitMatcher ( const edm::ParameterSet & iConfig )

explicit

Definition at line 77 of file FastTrackerRecHitMatcher.cc.

References edm::ParameterSet::getParameter(), simHit2RecHitMapToken, and simHitsToken.

     : trackerGeometryESToken(esConsumes()) {
   simHitsToken = consumes<edm::PSimHitContainer>(iConfig.getParameter<edm::InputTag>("simHits"));
   simHit2RecHitMapToken =
       consumes<FastTrackerRecHitRefCollection>(iConfig.getParameter<edm::InputTag>("simHit2RecHitMap"));
 
   produces<FastTrackerRecHitCollection>();
   produces<FastTrackerRecHitRefCollection>("simHit2RecHitMap");
 }

◆ ~FastTrackerRecHitMatcher()

FastTrackerRecHitMatcher::~FastTrackerRecHitMatcher ( )

inlineoverride

Definition at line 33 of file FastTrackerRecHitMatcher.cc.

33 { ; }

Member Function Documentation

◆ _cast2Single()

const FastSingleTrackerRecHit* FastTrackerRecHitMatcher::_cast2Single ( const FastTrackerRecHit * recHit ) const

inlineprivate

Definition at line 62 of file FastTrackerRecHitMatcher.cc.

References Exception, and rpcPointValidation_cfi::recHit.

Referenced by produce().

                                                                                             {
     if (!recHit->isSingle()) {
       throw cms::Exception("FastTrackerRecHitMatcher")
           << "all rechits in simHit2RecHitMap must be instances of FastSingleTrackerRecHit. recHit's rtti: "
           << recHit->rtti() << std::endl;
     }
     return dynamic_cast<const FastSingleTrackerRecHit*>(recHit);
   }

◆ fillDescriptions()

void FastTrackerRecHitMatcher::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 355 of file FastTrackerRecHitMatcher.cc.

References edm::ConfigurationDescriptions::addDefault(), and submitPVResolutionJobs::desc.

                                                                                           {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

◆ match()

std::unique_ptr< FastTrackerRecHit > FastTrackerRecHitMatcher::match	(	const FastSingleTrackerRecHit *	monoRH,
		const FastSingleTrackerRecHit *	stereoRH,
		const GluedGeomDet *	gluedDet,
		LocalVector &	trackdirection,
		bool	stereLayerFirst
	)		const

private

Definition at line 195 of file FastTrackerRecHitMatcher.cc.

References HltBtagPostValidation_cff::c, alignmentValidation::c1, funct::cos(), change_name::diff, relativeConstraints::error, Exception, TrackingRecHit::geographicalId(), StripTopology::localPitch(), StripTopology::localPosition(), BaseTrackerRecHit::localPosition(), BaseTrackerRecHit::localPositionError(), visualization-live-secondInstance_cfg::m, PV3DBase< T, PVType, FrameType >::mag2(), Topology::measurementError(), Topology::measurementPosition(), GluedGeomDet::monoDet(), PV3DBase< T, PVType, FrameType >::phi(), position, project(), funct::sin(), GluedGeomDet::stereoDet(), GeomDet::surface(), toLocal(), GeomDet::topology(), PV2DBase< T, PVType, FrameType >::x(), geometryCSVtoXML::xx, geometryCSVtoXML::xy, and geometryCSVtoXML::yy.

Referenced by produce().

                                                                                               {
   // stripdet = mono
   // partnerstripdet = stereo
   const GeomDetUnit* stripdet = gluedDet->monoDet();
   const GeomDetUnit* partnerstripdet = gluedDet->stereoDet();
   const StripTopology& topol = (const StripTopology&)stripdet->topology();
 
   LocalPoint position;
 
   // position of the initial and final point of the strip (RPHI cluster) in local strip coordinates
   MeasurementPoint RPHIpoint = topol.measurementPosition(monoRH->localPosition());
   MeasurementPoint RPHIpointini = MeasurementPoint(RPHIpoint.x(), -0.5);
   MeasurementPoint RPHIpointend = MeasurementPoint(RPHIpoint.x(), 0.5);
 
   // position of the initial and final point of the strip in local coordinates (mono det)
   StripPosition stripmono = StripPosition(topol.localPosition(RPHIpointini), topol.localPosition(RPHIpointend));
 
   // in case of no track hypothesis assume a track from the origin through the center of the strip
   if (trackdirection.mag2() < FLT_MIN) {
     LocalPoint lcenterofstrip = monoRH->localPosition();
     GlobalPoint gcenterofstrip = (stripdet->surface()).toGlobal(lcenterofstrip);
     GlobalVector gtrackdirection = gcenterofstrip - GlobalPoint(0, 0, 0);
     trackdirection = (gluedDet->surface()).toLocal(gtrackdirection);
   }
 
   //project mono hit on glued det
   StripPosition projectedstripmono = project(stripdet, gluedDet, stripmono, trackdirection);
   const StripTopology& partnertopol = (const StripTopology&)partnerstripdet->topology();
 
   //error calculation (the part that depends on mono RH only)
   LocalVector RPHIpositiononGluedendvector = projectedstripmono.second - projectedstripmono.first;
   double c1 = sin(RPHIpositiononGluedendvector.phi());
   double s1 = -cos(RPHIpositiononGluedendvector.phi());
   MeasurementError errormonoRH = topol.measurementError(monoRH->localPosition(), monoRH->localPositionError());
   double pitch = topol.localPitch(monoRH->localPosition());
   double sigmap12 = errormonoRH.uu() * pitch * pitch;
 
   // position of the initial and final point of the strip (STEREO cluster)
   MeasurementPoint STEREOpoint = partnertopol.measurementPosition(stereoRH->localPosition());
 
   MeasurementPoint STEREOpointini = MeasurementPoint(STEREOpoint.x(), -0.5);
   MeasurementPoint STEREOpointend = MeasurementPoint(STEREOpoint.x(), 0.5);
 
   // position of the initial and final point of the strip in local coordinates (stereo det)
   StripPosition stripstereo(partnertopol.localPosition(STEREOpointini), partnertopol.localPosition(STEREOpointend));
 
   //project stereo hit on glued det
   StripPosition projectedstripstereo = project(partnerstripdet, gluedDet, stripstereo, trackdirection);
 
   //perform the matching
   //(x2-x1)(y-y1)=(y2-y1)(x-x1)
   AlgebraicMatrix22 m;
   AlgebraicVector2 c, solution;
   m(0, 0) = -(projectedstripmono.second.y() - projectedstripmono.first.y());
   m(0, 1) = (projectedstripmono.second.x() - projectedstripmono.first.x());
   m(1, 0) = -(projectedstripstereo.second.y() - projectedstripstereo.first.y());
   m(1, 1) = (projectedstripstereo.second.x() - projectedstripstereo.first.x());
   c(0) = m(0, 1) * projectedstripmono.first.y() + m(0, 0) * projectedstripmono.first.x();
   c(1) = m(1, 1) * projectedstripstereo.first.y() + m(1, 0) * projectedstripstereo.first.x();
   m.Invert();
   solution = m * c;
   position = LocalPoint(solution(0), solution(1));
 
   //
   // temporary fix by tommaso
   //
 
   LocalError tempError(100, 0, 100);
 
   // calculate the error
   LocalVector stereopositiononGluedendvector = projectedstripstereo.second - projectedstripstereo.first;
   double c2 = sin(stereopositiononGluedendvector.phi());
   double s2 = -cos(stereopositiononGluedendvector.phi());
   MeasurementError errorstereoRH =
       partnertopol.measurementError(stereoRH->localPosition(), stereoRH->localPositionError());
   pitch = partnertopol.localPitch(stereoRH->localPosition());
   double sigmap22 = errorstereoRH.uu() * pitch * pitch;
   double diff = (c1 * s2 - c2 * s1);
   double invdet2 = 1 / (diff * diff);
   float xx = invdet2 * (sigmap12 * s2 * s2 + sigmap22 * s1 * s1);
   float xy = -invdet2 * (sigmap12 * c2 * s2 + sigmap22 * c1 * s1);
   float yy = invdet2 * (sigmap12 * c2 * c2 + sigmap22 * c1 * c1);
   LocalError error = LocalError(xx, xy, yy);
 
   //Added by DAO to make sure y positions are zero.
   DetId det(monoRH->geographicalId());
   if (det.subdetId() > 2) {
     return std::make_unique<FastMatchedTrackerRecHit>(position, error, *gluedDet, *monoRH, *stereoRH, stereoHitFirst);
 
   }
 
   else {
     throw cms::Exception("FastTrackerRecHitMatcher") << "Matched Pixel!?";
   }
 }

◆ produce()

void FastTrackerRecHitMatcher::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 87 of file FastTrackerRecHitMatcher.cc.

References _cast2Single(), edm::Ref< C, T, F >::get(), edm::EventSetup::getData(), StripSubdetector::glued(), iEvent, edm::Ref< C, T, F >::isNull(), match(), eostools::move(), projectOnly(), DetId::rawId(), rpcPointValidation_cfi::recHit, rpcPointValidation_cfi::simHit, Reconstruction_BefMix_cff::simHit2RecHitMap, simHit2RecHitMapToken, FastTrackerRecHitCombiner_cfi::simHits, simHitsToken, StripSubdetector::stereo(), GeomDet::surface(), GloballyPositioned< T >::toLocal(), trackerGeometryESToken, and PSimHit::trackId().

                                                                                     {
   // services
   auto const& geometry = iSetup.getData(trackerGeometryESToken);
 
   // input
   edm::Handle<edm::PSimHitContainer> simHits;
   iEvent.getByToken(simHitsToken, simHits);
 
   edm::Handle<FastTrackerRecHitRefCollection> simHit2RecHitMap;
   iEvent.getByToken(simHit2RecHitMapToken, simHit2RecHitMap);
 
   // output
   auto output_recHits = std::make_unique<FastTrackerRecHitCollection>();
   auto output_simHit2RecHitMap =
       std::make_unique<FastTrackerRecHitRefCollection>(simHit2RecHitMap->size(), FastTrackerRecHitRef());
   edm::RefProd<FastTrackerRecHitCollection> output_recHits_refProd =
       iEvent.getRefBeforePut<FastTrackerRecHitCollection>();
 
   bool skipNext = false;
   for (unsigned simHitCounter = 0; simHitCounter < simHits->size(); ++simHitCounter) {
     // skip hit in case it was matched to previous one
     if (skipNext) {
       skipNext = false;
       continue;
     }
     skipNext = false;
 
     // get simHit and associated recHit
     const PSimHit& simHit = (*simHits)[simHitCounter];
     const FastTrackerRecHitRef& recHitRef = (*simHit2RecHitMap)[simHitCounter];
 
     // skip simHits w/o associated recHit
     if (recHitRef.isNull())
       continue;
 
     // cast
     const FastSingleTrackerRecHit* recHit = _cast2Single(recHitRef.get());
 
     // get subdetector id
     DetId detid = recHit->geographicalId();
     unsigned int subdet = detid.subdetId();
 
     // treat pixel hits
     if (subdet <= 2) {
       (*output_simHit2RecHitMap)[simHitCounter] = recHitRef;
     }
 
     // treat strip hits
     else {
       StripSubdetector stripSubDetId(detid);
 
       // treat regular regular strip hits
       if (!stripSubDetId.glued()) {
         (*output_simHit2RecHitMap)[simHitCounter] = recHitRef;
       }
 
       // treat strip hits on glued layers
       else {
         // Obtain direction of simtrack at simhit in local coordinates of glued module
         //   - direction of simtrack at simhit, in coordindates of the single module
         LocalVector localSimTrackDir = simHit.localDirection();
         //   - transform to global coordinates
         GlobalVector globalSimTrackDir = recHit->det()->surface().toGlobal(localSimTrackDir);
         //   - transform to local coordinates of glued module
         const GluedGeomDet* gluedDet = (const GluedGeomDet*)geometry.idToDet(DetId(stripSubDetId.glued()));
         LocalVector gluedLocalSimTrackDir = gluedDet->surface().toLocal(globalSimTrackDir);
 
         // check whether next hit is partner
         const FastSingleTrackerRecHit* partnerRecHit = nullptr;
         //      - there must be a next hit
         if (simHitCounter + 1 < simHits->size()) {
           const FastTrackerRecHitRef& nextRecHitRef = (*simHit2RecHitMap)[simHitCounter + 1];
           const PSimHit& nextSimHit = (*simHits)[simHitCounter + 1];
           //  - partner hit must not be null
           //  - simHit and partner simHit must belong to same simTrack
           //  - partner hit must be on the module glued to the module of the hit
           if ((!nextRecHitRef.isNull()) && simHit.trackId() == nextSimHit.trackId() &&
               StripSubdetector(nextRecHitRef->geographicalId()).partnerDetId() == detid.rawId()) {
             partnerRecHit = _cast2Single(nextRecHitRef.get());
             skipNext = true;
           }
         }
 
         std::unique_ptr<FastTrackerRecHit> newRecHit(nullptr);
 
         // if partner found: create a matched hit
         if (partnerRecHit) {
           newRecHit = match(stripSubDetId.stereo() ? partnerRecHit : recHit,
                             stripSubDetId.stereo() ? recHit : partnerRecHit,
                             gluedDet,
                             gluedLocalSimTrackDir,
                             stripSubDetId.stereo());
         }
         // else: create projected hit
         else {
           newRecHit = projectOnly(recHit, geometry.idToDet(detid), gluedDet, gluedLocalSimTrackDir);
         }
         output_recHits->push_back(std::move(newRecHit));
         (*output_simHit2RecHitMap)[simHitCounter] =
             FastTrackerRecHitRef(output_recHits_refProd, output_recHits->size() - 1);
       }
     }
   }
 
   iEvent.put(std::move(output_recHits));
   iEvent.put(std::move(output_simHit2RecHitMap), "simHit2RecHitMap");
 }

◆ project()

FastTrackerRecHitMatcher::StripPosition FastTrackerRecHitMatcher::project	(	const GeomDetUnit *	det,
		const GluedGeomDet *	glueddet,
		const StripPosition &	strip,
		const LocalVector &	trackdirection
	)		const

private

Definition at line 295 of file FastTrackerRecHitMatcher.cc.

References pfClustersFromCombinedCaloHF_cfi::scale, digitizers_cfi::strip, GeomDet::surface(), toLocal(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by match().

                                                                                                                    {
   GlobalPoint globalpointini = (det->surface()).toGlobal(strip.first);
   GlobalPoint globalpointend = (det->surface()).toGlobal(strip.second);
 
   // position of the initial and final point of the strip in glued local coordinates
   LocalPoint positiononGluedini = (glueddet->surface()).toLocal(globalpointini);
   LocalPoint positiononGluedend = (glueddet->surface()).toLocal(globalpointend);
 
   //correct the position with the track direction
 
   float scale = -positiononGluedini.z() / trackdirection.z();
 
   LocalPoint projpositiononGluedini = positiononGluedini + scale * trackdirection;
   LocalPoint projpositiononGluedend = positiononGluedend + scale * trackdirection;
 
   return StripPosition(projpositiononGluedini, projpositiononGluedend);
 }

◆ projectOnly()

std::unique_ptr< FastTrackerRecHit > FastTrackerRecHitMatcher::projectOnly	(	const FastSingleTrackerRecHit *	originalRH,
		const GeomDet *	monoDet,
		const GluedGeomDet *	gluedDet,
		LocalVector &	ldir
	)		const

private

Definition at line 316 of file FastTrackerRecHitMatcher.cc.

References dumpMFGeometry_cfg::delta, Exception, GeomDet::geographicalId(), BaseTrackerRecHit::localPosition(), BaseTrackerRecHit::localPositionError(), GluedGeomDet::monoDet(), position, LocalError::rotate(), GluedGeomDet::stereoDet(), GeomDet::surface(), Surface::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), LocalError::xx(), LocalError::xy(), PV3DBase< T, PVType, FrameType >::y(), LocalError::yy(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by produce().

                                                                                                   {
   LocalPoint position(originalRH->localPosition().x(), 0., 0.);
   const BoundPlane& gluedPlane = gluedDet->surface();
   const BoundPlane& hitPlane = monoDet->surface();
 
   double delta = gluedPlane.localZ(hitPlane.position());
 
   LocalPoint lhitPos = gluedPlane.toLocal(monoDet->surface().toGlobal(position));
   LocalPoint projectedHitPos = lhitPos - ldir * delta / ldir.z();
 
   LocalVector hitXAxis = gluedPlane.toLocal(hitPlane.toGlobal(LocalVector(1, 0, 0)));
   LocalError hitErr = originalRH->localPositionError();
 
   if (gluedPlane.normalVector().dot(hitPlane.normalVector()) < 0) {
     // the two planes are inverted, and the correlation element must change sign
     hitErr = LocalError(hitErr.xx(), -hitErr.xy(), hitErr.yy());
   }
   LocalError rotatedError = hitErr.rotate(hitXAxis.x(), hitXAxis.y());
 
   const GeomDetUnit* gluedMonoDet = gluedDet->monoDet();
   const GeomDetUnit* gluedStereoDet = gluedDet->stereoDet();
   int isMono = 0;
   int isStereo = 0;
 
   if (monoDet->geographicalId() == gluedMonoDet->geographicalId())
     isMono = 1;
   if (monoDet->geographicalId() == gluedStereoDet->geographicalId())
     isStereo = 1;
   //Added by DAO to make sure y positions are zero and correct Mono or stereo Det is filled.
 
   if ((isMono && isStereo) || (!isMono && !isStereo))
     throw cms::Exception("FastTrackerRecHitMatcher") << "Something wrong with DetIds.";
   return std::make_unique<FastProjectedTrackerRecHit>(projectedHitPos, rotatedError, *gluedDet, *originalRH);
 }