Inheritance diagram for FastTrackerRecHitMatcher:

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

	~FastTrackerRecHitMatcher ()

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (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

virtual 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

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 32 of file FastTrackerRecHitMatcher.cc.

Member Typedef Documentation

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

private

Definition at line 45 of file FastTrackerRecHitMatcher.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 80 of file FastTrackerRecHitMatcher.cc.

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

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

FastTrackerRecHitMatcher::~FastTrackerRecHitMatcher ( )

inline

Definition at line 37 of file FastTrackerRecHitMatcher.cc.

References fillDescriptions(), and produce().

37 {;}

Member Function Documentation

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

inlineprivate

Definition at line 67 of file FastTrackerRecHitMatcher.cc.

References Exception, BaseTrackerRecHit::isSingle(), rpcPointValidation_cfi::recHit, and BaseTrackerRecHit::rtti().

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);
     }

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

static

Definition at line 366 of file FastTrackerRecHitMatcher.cc.

References edm::ConfigurationDescriptions::addDefault(), DEFINE_FWK_MODULE, and edm::ParameterSetDescription::setUnknown().

Referenced by ~FastTrackerRecHitMatcher().

                                                                                           {
     //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);
 }

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

private

Definition at line 202 of file FastTrackerRecHitMatcher.cc.

References EnergyCorrector::c, alignmentValidation::c1, funct::cos(), mps_update::diff, relativeConstraints::error, Exception, TrackingRecHit::geographicalId(), StripTopology::localPitch(), StripTopology::localPosition(), BaseTrackerRecHit::localPosition(), BaseTrackerRecHit::localPositionError(), funct::m, PV3DBase< T, PVType, FrameType >::mag2(), Topology::measurementError(), Topology::measurementPosition(), GluedGeomDet::monoDet(), PV3DBase< T, PVType, FrameType >::phi(), position, project(), indexGen::s2, 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));
 
     if(trackdirection.mag2()<FLT_MIN){// in case of no track hypothesis assume a track from the origin through the center of the strip
     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!?";
     }
 }

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

overrideprivatevirtual

Definition at line 91 of file FastTrackerRecHitMatcher.cc.

References _cast2Single(), TrackingRecHit::det(), TrackingRecHit::geographicalId(), geometry, edm::EventSetup::get(), edm::Ref< C, T, F >::get(), edm::Event::getByToken(), edm::Event::getRefBeforePut(), StripSubdetector::glued(), TrackerGeometry::idToDet(), edm::Ref< C, T, F >::isNull(), PSimHit::localDirection(), match(), eostools::move(), projectOnly(), edm::Event::put(), DetId::rawId(), rpcPointValidation_cfi::recHit, rpcPointValidation_cfi::simHit, simHit2RecHitMapToken, trackerHits::simHits, simHitsToken, StripSubdetector::stereo(), DetId::subdetId(), GeomDet::surface(), Surface::toGlobal(), GloballyPositioned< T >::toLocal(), and PSimHit::trackId().

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), HTMLExport.HTMLExportStatic::export(), and ~FastTrackerRecHitMatcher().

 {
     // services
     edm::ESHandle<TrackerGeometry> geometry;
     iSetup.get<TrackerDigiGeometryRecord> ().get (geometry);
 
     // 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 = 0;
         //      - 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");
 
 }

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

private

Definition at line 301 of file FastTrackerRecHitMatcher.cc.

References Scenarios_cff::scale, 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);
 }

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

private

Definition at line 326 of file FastTrackerRecHitMatcher.cc.

References 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);
 }