Inheritance diagram for ME0SegmentMatcher:

Public Member Functions
void	beginRun (edm::Run const &, edm::EventSetup const &) override

void	getFromFTS (const FreeTrajectoryState &, GlobalVector &, GlobalVector &, int &, AlgebraicSymMatrix66 &)

FreeTrajectoryState	getFTS (const GlobalVector &, const GlobalVector &, int, const AlgebraicSymMatrix66 &, const MagneticField *)

FreeTrajectoryState	getFTS (const GlobalVector &, const GlobalVector &, int, const AlgebraicSymMatrix55 &, const MagneticField *)

	ME0SegmentMatcher (const edm::ParameterSet &)
	Constructor. More...

void	produce (edm::Event &, const edm::EventSetup &) override
	Produce the ME0Segment collection. More...

	~ME0SegmentMatcher () override
	Destructor. More...

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

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

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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 ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

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, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
edm::InputTag	generalTracksTag

edm::EDGetTokenT< reco::TrackCollection >	generalTracksToken_

edm::InputTag	OurSegmentsTag

edm::EDGetTokenT< ME0SegmentCollection >	OurSegmentsToken_

double	thePHIDIR_RESIDUAL_CUT

double	theX_PULL_CUT

double	theX_RESIDUAL_CUT

double	theY_PULL_CUT

double	theY_RESIDUAL_CUT

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
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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 ME0SegmentMatcher.cc.

Constructor & Destructor Documentation

ME0SegmentMatcher::ME0SegmentMatcher ( const edm::ParameterSet & pas )

explicit

Constructor.

Definition at line 64 of file ME0SegmentMatcher.cc.

References generalTracksTag, generalTracksToken_, edm::ParameterSet::getParameter(), OurSegmentsTag, OurSegmentsToken_, thePHIDIR_RESIDUAL_CUT, theX_PULL_CUT, theX_RESIDUAL_CUT, theY_PULL_CUT, and theY_RESIDUAL_CUT.

                                                                {
   produces<std::vector<reco::ME0Muon> >();  
   theX_PULL_CUT   = pas.getParameter<double>("maxPullX");
   theX_RESIDUAL_CUT   = pas.getParameter<double>("maxDiffX");
   theY_PULL_CUT   = pas.getParameter<double>("maxPullY");
   theY_RESIDUAL_CUT   = pas.getParameter<double>("maxDiffY");
   thePHIDIR_RESIDUAL_CUT   = pas.getParameter<double>("maxDiffPhiDirection");
   //Might need to replace "OurSegments" with an edm::InputTag of "OurSegments"
   OurSegmentsTag = pas.getParameter<edm::InputTag>("me0SegmentTag");
   generalTracksTag = pas.getParameter<edm::InputTag>("tracksTag");
   OurSegmentsToken_ = consumes<ME0SegmentCollection>(OurSegmentsTag);
   generalTracksToken_ = consumes<reco::TrackCollection>(generalTracksTag);
 
 }

ME0SegmentMatcher::~ME0SegmentMatcher ( )

override

Destructor.

Definition at line 79 of file ME0SegmentMatcher.cc.

79 {}

Member Function Documentation

void ME0SegmentMatcher::beginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 271 of file ME0SegmentMatcher.cc.

References DEFINE_FWK_MODULE.

271 {}

void ME0SegmentMatcher::getFromFTS	(	const FreeTrajectoryState &	fts,
		GlobalVector &	p3,
		GlobalVector &	r3,
		int &	charge,
		AlgebraicSymMatrix66 &	cov
	)

Definition at line 254 of file ME0SegmentMatcher.cc.

References FreeTrajectoryState::cartesianError(), FreeTrajectoryState::charge(), FreeTrajectoryState::hasError(), CartesianTrajectoryError::matrix(), FreeTrajectoryState::momentum(), FreeTrajectoryState::position(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by produce().

                                                           {
   GlobalVector p3GV = fts.momentum();
   GlobalPoint r3GP = fts.position();
 
   GlobalVector p3T(p3GV.x(), p3GV.y(), p3GV.z());
   GlobalVector r3T(r3GP.x(), r3GP.y(), r3GP.z());
   p3 = p3T;
   r3 = r3T;  
   // p3.set(p3GV.x(), p3GV.y(), p3GV.z());
   // r3.set(r3GP.x(), r3GP.y(), r3GP.z());
   
   charge = fts.charge();
   cov = fts.hasError() ? fts.cartesianError().matrix() : AlgebraicSymMatrix66();
 }

FreeTrajectoryState ME0SegmentMatcher::getFTS	(	const GlobalVector &	p3,
		const GlobalVector &	r3,
		int	charge,
		const AlgebraicSymMatrix66 &	cov,
		const MagneticField *	field
	)

Definition at line 241 of file ME0SegmentMatcher.cc.

References PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by produce().

                                          {
 
   GlobalVector p3GV(p3.x(), p3.y(), p3.z());
   GlobalPoint r3GP(r3.x(), r3.y(), r3.z());
   GlobalTrajectoryParameters tPars(r3GP, p3GV, charge, field);
 
   CartesianTrajectoryError tCov(cov);
   
   return cov.kRows == 6 ? FreeTrajectoryState(tPars, tCov) : FreeTrajectoryState(tPars) ;
 }

FreeTrajectoryState ME0SegmentMatcher::getFTS	(	const GlobalVector &	p3,
		const GlobalVector &	r3,
		int	charge,
		const AlgebraicSymMatrix55 &	cov,
		const MagneticField *	field
	)

Definition at line 227 of file ME0SegmentMatcher.cc.

References PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                          {
 
   GlobalVector p3GV(p3.x(), p3.y(), p3.z());
   GlobalPoint r3GP(r3.x(), r3.y(), r3.z());
   GlobalTrajectoryParameters tPars(r3GP, p3GV, charge, field);
 
   CurvilinearTrajectoryError tCov(cov);
   
   return cov.kRows == 5 ? FreeTrajectoryState(tPars, tCov) : FreeTrajectoryState(tPars) ;
 }

void ME0SegmentMatcher::produce	(	edm::Event &	ev,
		const edm::EventSetup &	setup
	)

override

Produce the ME0Segment collection.

Definition at line 81 of file ME0SegmentMatcher.cc.

References funct::abs(), PV3DBase< T, PVType, FrameType >::barePhi(), barePhi(), ecalTB2006H4_GenSimDigiReco_cfg::bField, Plane::build(), patCaloMETCorrections_cff::C, relativeConstraints::chamber, ME0Geometry::chamber(), reco::deltaPhi(), reco::deltaR2(), TrajectoryStateOnSurface::freeTrajectoryState(), isolatedTracks_cfi::generalTracks, generalTracksToken_, edm::EventSetup::get(), edm::Event::getByToken(), getFromFTS(), getFTS(), mps_fire::i, TrajectoryStateOnSurface::isValid(), JacobianCartesianToLocal::jacobian(), eostools::move(), OurSegmentsToken_, Propagator::propagate(), edm::Event::put(), reco::ME0Muon::setGlobalTrackCov(), reco::ME0Muon::setGlobalTrackMomAtSurface(), reco::ME0Muon::setGlobalTrackPosAtSurface(), reco::ME0Muon::setLocalTrackCov(), reco::ME0Muon::setLocalTrackMomAtSurface(), reco::ME0Muon::setLocalTrackPosAtSurface(), mathSSE::sqrt(), thePHIDIR_RESIDUAL_CUT, theX_PULL_CUT, theX_RESIDUAL_CUT, theY_PULL_CUT, theY_RESIDUAL_CUT, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), z, and PV3DBase< T, PVType, FrameType >::z().

                                                                         {
 
   //Getting the objects we'll need
   using namespace edm;
 
   ESHandle<ME0Geometry> me0Geom;
   setup.get<MuonGeometryRecord>().get(me0Geom);
   ESHandle<MagneticField> bField;
   setup.get<IdealMagneticFieldRecord>().get(bField);
   ESHandle<Propagator> ThisshProp;
   setup.get<TrackingComponentsRecord>().get("SteppingHelixPropagatorAlong", ThisshProp);
 
   using namespace reco;
 
   Handle<ME0SegmentCollection> OurSegments;
   ev.getByToken(OurSegmentsToken_,OurSegments);
 
   auto oc = std::make_unique<std::vector<ME0Muon>>(); 
   std::vector<ME0Muon> TempStore; 
 
   Handle <TrackCollection > generalTracks;
   ev.getByToken(generalTracksToken_,generalTracks);
 
   int TrackNumber = 0;
     
   for (std::vector<Track>::const_iterator thisTrack = generalTracks->begin();
        thisTrack != generalTracks->end(); ++thisTrack,++TrackNumber){
     //Initializing our plane
 
     //Remove later
     if (std::abs(thisTrack->eta()) < 1.8) continue;
 
     //Getting the initial variables for propagation
     float zSign = thisTrack->pz() > 0 ? 1.0f : -1.0f;
 
     ReferenceCountingPointer<Plane> plane = Plane::build(Surface::PositionType(0,0,zSign*526.75),Surface::RotationType());
 
     int chargeReco = thisTrack->charge(); 
     GlobalVector p3reco, r3reco;
 
     p3reco = GlobalVector(thisTrack->outerPx(), thisTrack->outerPy(), thisTrack->outerPz());
     r3reco = GlobalVector(thisTrack->outerX(), thisTrack->outerY(), thisTrack->outerZ());
 
     AlgebraicSymMatrix66 covReco;
     //This is to fill the cov matrix correctly
     const AlgebraicSymMatrix55 & covReco_curv = thisTrack->outerStateCovariance();
     FreeTrajectoryState initrecostate = getFTS(p3reco, r3reco, chargeReco, covReco_curv, &*bField);
     getFromFTS(initrecostate, p3reco, r3reco, chargeReco, covReco);
 
     //Now we propagate and get the propagated variables from the propagated state
     TrajectoryStateOnSurface lastrecostate = ThisshProp->propagate(initrecostate,*plane);
     if (!lastrecostate.isValid()) continue;
     
     FreeTrajectoryState finalrecostate(*lastrecostate.freeTrajectoryState());
 
     AlgebraicSymMatrix66 covFinalReco;
     GlobalVector p3FinalReco_glob, r3FinalReco_globv;
     getFromFTS(finalrecostate, p3FinalReco_glob, r3FinalReco_globv, chargeReco, covFinalReco);
 
     //To transform the global propagated track to local coordinates
     int SegmentNumber = 0;
 
     reco::ME0Muon MuonCandidate;
     double ClosestDelR2 = 999.;
 
     for (auto thisSegment = OurSegments->begin(); thisSegment != OurSegments->end(); 
      ++thisSegment,++SegmentNumber){
       ME0DetId id = thisSegment->me0DetId();
 
       auto chamber = me0Geom->chamber(id);
 
       if ( zSign * chamber->toGlobal(thisSegment->localPosition()).z() < 0 ) continue;
 
       GlobalPoint r3FinalReco_glob(r3FinalReco_globv.x(),r3FinalReco_globv.y(),r3FinalReco_globv.z());
 
       LocalPoint r3FinalReco = chamber->toLocal(r3FinalReco_glob);
       LocalVector p3FinalReco=chamber->toLocal(p3FinalReco_glob);
 
       LocalPoint thisPosition(thisSegment->localPosition());
       LocalVector thisDirection(thisSegment->localDirection().x(),thisSegment->localDirection().y(),thisSegment->localDirection().z());  //FIXME
 
       //The same goes for the error
       AlgebraicMatrix thisCov(4,4,0);   
       for (int i = 1; i <=4; i++){
     for (int j = 1; j <=4; j++){
       thisCov(i,j) = thisSegment->parametersError()(i,j);
     }
       }
 
       LocalTrajectoryParameters ltp(r3FinalReco,p3FinalReco,chargeReco);
       JacobianCartesianToLocal jctl(chamber->surface(),ltp);
       const AlgebraicMatrix56& jacobGlbToLoc = jctl.jacobian(); 
 
       AlgebraicMatrix55 Ctmp =  (jacobGlbToLoc * covFinalReco) * ROOT::Math::Transpose(jacobGlbToLoc); 
       AlgebraicSymMatrix55 C;  // I couldn't find any other way, so I resort to the brute force
       for(int i=0; i<5; ++i) {
     for(int j=0; j<5; ++j) {
       C[i][j] = Ctmp[i][j]; 
 
     }
       }  
 
       Double_t sigmax = sqrt(C[3][3]+thisSegment->localPositionError().xx() );      
       Double_t sigmay = sqrt(C[4][4]+thisSegment->localPositionError().yy() );
 
       bool X_MatchFound = false, Y_MatchFound = false, Dir_MatchFound = false;
     
       if ( (std::abs(thisPosition.x()-r3FinalReco.x()) < (theX_PULL_CUT * sigmax)) || (std::abs(thisPosition.x()-r3FinalReco.x()) < theX_RESIDUAL_CUT ) ) X_MatchFound = true;
       if ( (std::abs(thisPosition.y()-r3FinalReco.y()) < (theY_PULL_CUT * sigmay)) || (std::abs(thisPosition.y()-r3FinalReco.y()) < theY_RESIDUAL_CUT ) ) Y_MatchFound = true;
 
       if ( std::abs(reco::deltaPhi(p3FinalReco_glob.barePhi(),chamber->toGlobal(thisSegment->localDirection()).barePhi())) < thePHIDIR_RESIDUAL_CUT) Dir_MatchFound = true;
 
       //Check for a Match, and if there is a match, check the delR from the segment, keeping only the closest in MuonCandidate
       if (X_MatchFound && Y_MatchFound && Dir_MatchFound) {
        
     TrackRef thisTrackRef(generalTracks,TrackNumber);
        
     GlobalPoint SegPos(chamber->toGlobal(thisSegment->localPosition()));
     GlobalPoint TkPos(r3FinalReco_globv.x(),r3FinalReco_globv.y(),r3FinalReco_globv.z());
        
     double thisDelR2 = reco::deltaR2(SegPos,TkPos);
     if (thisDelR2 < ClosestDelR2){
       ClosestDelR2 = thisDelR2;
       MuonCandidate = reco::ME0Muon(thisTrackRef,(*thisSegment),SegmentNumber,chargeReco);
 
       MuonCandidate.setGlobalTrackPosAtSurface(r3FinalReco_glob);
       MuonCandidate.setGlobalTrackMomAtSurface(p3FinalReco_glob);
       MuonCandidate.setLocalTrackPosAtSurface(r3FinalReco);
       MuonCandidate.setLocalTrackMomAtSurface(p3FinalReco);
       MuonCandidate.setGlobalTrackCov(covFinalReco);
       MuonCandidate.setLocalTrackCov(C);
     }
       }
     }//End loop for (auto thisSegment = OurSegments->begin(); thisSegment != OurSegments->end(); ++thisSegment,++SegmentNumber)
 
     //As long as the delR of the MuonCandidate is sensible, store the track-segment pair
     if (ClosestDelR2 < 500.) {
       oc->push_back(MuonCandidate);
     }
   }
 
   // put collection in event
   ev.put(std::move(oc));        
 }