#include <HLTMuonPointingFilter.h>

Inheritance diagram for HLTMuonPointingFilter:

Public Member Functions
bool	filter (edm::Event &, edm::EventSetup const &) override

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

	~HLTMuonPointingFilter () override
	Destructor. More...

Public Member Functions inherited from edm::EDFilter
	EDFilter ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

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

	~ProducerBase () noexcept(false) override

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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Private Attributes
unsigned long long	m_cacheRecordId

Cylinder::CylinderPointer	theCyl

const double	theMaxZ

const unsigned int	theMuonHits

Plane::PlanePointer	theNegPlane

const unsigned int	thePixHits

Plane::PlanePointer	thePosPlane

Propagator *	thePropagator

const std::string	thePropagatorName

const double	theRadius

const edm::EDGetTokenT< reco::TrackCollection >	theSTAMuonToken

const unsigned int	theTkLayers

Additional Inherited Members
Public Types inherited from edm::EDFilter
typedef EDFilter	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

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

EDFilter to select muons that points to a cylinder of configurable radius and lenght.

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

Definition at line 32 of file HLTMuonPointingFilter.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 37 of file HLTMuonPointingFilter.cc.

References Plane::build(), Cylinder::build(), edm::ParameterSet::getParameter(), LogDebug, theCyl, theMaxZ, theMuonHits, theNegPlane, thePixHits, thePosPlane, theRadius, theTkLayers, and ~HLTMuonPointingFilter().

                                                                         :
   theSTAMuonToken(  consumes<reco::TrackCollection>( pset.getParameter<edm::InputTag>("SALabel") ) ),      // token to read the muons
   thePropagatorName(pset.getParameter<std::string>("PropagatorName") ),
   theRadius(        pset.getParameter<double>("radius") ),              // cyl's radius (cm)
   theMaxZ(          pset.getParameter<double>("maxZ") ),                // cyl's half lenght (cm)
   thePixHits(       pset.getParameter<unsigned int>("PixHits") ),       // pixel hits
   theTkLayers(      pset.getParameter<unsigned int>("TkLayers") ),      // tracker layers with measurements
   theMuonHits(      pset.getParameter<unsigned int>("MuonHits") ),      // muon hits
   thePropagator(nullptr),
   m_cacheRecordId(0)
 {
   // Get a surface (here a cylinder of radius 1290mm) ECAL
   Cylinder::PositionType pos0;
   Cylinder::RotationType rot0;
   theCyl = Cylinder::build(theRadius, pos0, rot0);
 
   Plane::PositionType posPos(0,0,theMaxZ);
   Plane::PositionType posNeg(0,0,-theMaxZ);
 
   thePosPlane = Plane::build(posPos,rot0);
   theNegPlane = Plane::build(posNeg,rot0);
 
   LogDebug("HLTMuonPointing") << " SALabel : " << pset.getParameter<edm::InputTag>("SALabel")
     << " Radius : " << theRadius
     << " Half lenght : " << theMaxZ
     << " Min pixel hits : " << thePixHits
     << " Min tk layers measurements : " << theTkLayers
     << " Min muon hits : " << theMuonHits;
 
 }

HLTMuonPointingFilter::~HLTMuonPointingFilter ( )

overridedefault

Destructor.

Referenced by HLTMuonPointingFilter().

Member Function Documentation

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

static

Definition at line 167 of file HLTMuonPointingFilter.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), DEFINE_FWK_MODULE, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                         {
   edm::ParameterSetDescription desc;
 
   desc.add<edm::InputTag>("SALabel", edm::InputTag("hltCosmicMuonBarrelOnly"));
   desc.add<std::string>("PropagatorName", "SteppingHelixPropagatorAny");
   desc.add<double>("radius", 90.0);
   desc.add<double>("maxZ", 280.0);
   desc.add<unsigned int>("PixHits",  0);
   desc.add<unsigned int>("TkLayers",  0);
   desc.add<unsigned int>("MuonHits", 0);
 
   descriptions.add("hltMuonPointingFilter", desc);
 }

bool HLTMuonPointingFilter::filter	(	edm::Event &	,
		edm::EventSetup const &
	)

overridevirtual

Implements edm::EDFilter.

Definition at line 72 of file HLTMuonPointingFilter.cc.

References accept(), anyDirection, edm::eventsetup::EventSetupRecord::cacheIdentifier(), Propagator::clone(), TrajectoryStateOnSurface::freeState(), edm::EventSetup::get(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), TrajectoryStateOnSurface::globalPosition(), reco::TransientTrack::hitPattern(), reco::TransientTrack::innermostMeasurementState(), TrajectoryStateOnSurface::isValid(), LogDebug, m_cacheRecordId, reco::HitPattern::numberOfValidMuonHits(), reco::HitPattern::numberOfValidPixelHits(), or, AlCaHLTBitMon_ParallelJobs::p, PV3DBase< T, PVType, FrameType >::perp(), NuclearInteractionSecond_cff::pixelHits, edm::ESHandle< T >::product(), Propagator::propagate(), Propagator::propagationDirection(), theCyl, theMaxZ, theMuonHits, theNegPlane, thePixHits, thePosPlane, thePropagator, thePropagatorName, theRadius, theSTAMuonToken, theTkLayers, HiIsolationCommonParameters_cff::track, reco::HitPattern::trackerLayersWithMeasurement(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                    {
   bool accept = false;
 
   const TrackingComponentsRecord & tkRec = eventSetup.get<TrackingComponentsRecord>();
   if (not thePropagator or tkRec.cacheIdentifier() != m_cacheRecordId) {
     // delete the old propagator
     delete thePropagator;
 
     // get the new propagator from the EventSetup and clone it (for thread safety)
     ESHandle<Propagator> propagatorHandle;
     tkRec.get(thePropagatorName, propagatorHandle);
     thePropagator = propagatorHandle.product()->clone();
     if (thePropagator->propagationDirection() != anyDirection)
       throw cms::Exception("Configuration") << "the propagator " << thePropagatorName << " should be configured with PropagationDirection = \"anyDirection\"" << std::endl;
     m_cacheRecordId = tkRec.cacheIdentifier();
   }
 
   ESHandle<MagneticField> theMGField;
   eventSetup.get<IdealMagneticFieldRecord>().get(theMGField);
 
   ESHandle<GlobalTrackingGeometry> theTrackingGeometry;
   eventSetup.get<GlobalTrackingGeometryRecord>().get(theTrackingGeometry);
 
   // Get the RecTrack collection from the event
   Handle<reco::TrackCollection> staTracks;
   event.getByToken(theSTAMuonToken, staTracks);
 
   reco::TrackCollection::const_iterator staTrack;
 
   for (staTrack = staTracks->begin(); staTrack != staTracks->end(); ++staTrack){
     reco::TransientTrack track(*staTrack,&*theMGField,theTrackingGeometry);
 
     const reco::HitPattern& p = track.hitPattern();
 
     const unsigned int pixelHits = p.numberOfValidPixelHits();
     const unsigned int trkLayers = p.trackerLayersWithMeasurement();
     const unsigned int nMuonHits = p.numberOfValidMuonHits();    
 
     TrajectoryStateOnSurface innerTSOS = track.innermostMeasurementState();
 
     LogDebug("HLTMuonPointing") << " InnerTSOS " << innerTSOS;
 
     TrajectoryStateOnSurface tsosAtCyl =
       thePropagator->propagate(*innerTSOS.freeState(), *theCyl);
 
     if ( tsosAtCyl.isValid() ) {
       LogDebug("HLTMuonPointing") << " extrap TSOS " << tsosAtCyl
         << " number of pixel hits " << pixelHits
         << " number of tracker layers with interactions " << trkLayers
     << " number of muon hits " << nMuonHits;
       if (fabs(tsosAtCyl.globalPosition().z())<theMaxZ ) {
     if(pixelHits >= thePixHits){
       if(trkLayers >= theTkLayers){
         if(nMuonHits >= theMuonHits){
           accept=true;
           return accept;
         }
       }
     }
       }
       else {
         LogDebug("HLTMuonPointing") << " extrap TSOS z too big " << tsosAtCyl.globalPosition().z()
       << " number of pixel hits " << pixelHits
       << " number of tracker layers with interactions " << trkLayers
       << " number of muon hits " << nMuonHits;
     TrajectoryStateOnSurface tsosAtPlane;
     if (tsosAtCyl.globalPosition().z()>0)
       tsosAtPlane=thePropagator->propagate(*innerTSOS.freeState(), *thePosPlane);
     else
       tsosAtPlane=thePropagator->propagate(*innerTSOS.freeState(), *theNegPlane);
 
     if (tsosAtPlane.isValid()){
       if (tsosAtPlane.globalPosition().perp()< theRadius){
         if (pixelHits >= thePixHits){
           if(trkLayers >= theTkLayers){
         if(nMuonHits >= theMuonHits){
           accept=true;
           return accept;
         }
           }
         }
       }
     }
     else
       LogDebug("HLTMuonPointing") << " extrap to plane failed ";
       }
     } else {
       LogDebug("HLTMuonPointing") << " extrap to cyl failed ";
     }
 
   }
 
   return accept;
 }