#include <Alignment/CommonAlignmentProducer/plugins/AlignmentMuonHIPTrajectorySelector.cc>

Inheritance diagram for AlignmentMuonHIPTrajectorySelector:

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

	~AlignmentMuonHIPTrajectorySelector () override

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

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

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

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

Private Attributes
bool	m_hists

edm::InputTag	m_input

double	m_maxMuonResidual

double	m_maxTrackerForwardRedChi2

double	m_minPt

int	m_minTrackerDOF

TH1F *	m_pt

TH1F *	m_resid_after

TH1F *	m_resid_before

TH1F *	m_tracker_dof

TH1F *	m_tracker_forwardredchi2

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	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::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 54 of file AlignmentMuonHIPTrajectorySelector.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 85 of file AlignmentMuonHIPTrajectorySelector.cc.

References m_hists, m_pt, m_resid_after, m_resid_before, m_tracker_dof, m_tracker_forwardredchi2, and TFileService::make().

     : m_input(iConfig.getParameter<edm::InputTag>("input")),
       m_minPt(iConfig.getParameter<double>("minPt")),
       m_maxTrackerForwardRedChi2(iConfig.getParameter<double>("maxTrackerForwardRedChi2")),
       m_minTrackerDOF(iConfig.getParameter<int>("minTrackerDOF")),
       m_maxMuonResidual(iConfig.getParameter<double>("maxMuonResidual")),
       m_hists(iConfig.getParameter<bool>("hists")),
       m_pt(nullptr),
       m_tracker_forwardredchi2(nullptr),
       m_tracker_dof(nullptr) {
   produces<TrajTrackAssociationCollection>();
 
   if (m_hists) {
     edm::Service<TFileService> fs;
     m_pt = fs->make<TH1F>("pt", "Transverse momentum (GeV)", 100, 0., 100.);
     m_tracker_forwardredchi2 =
         fs->make<TH1F>("trackerForwardRedChi2", "forward-biased reduced chi2 in tracker", 100, 0., 5.);
     m_tracker_dof = fs->make<TH1F>("trackerDOF", "DOF in tracker", 61, -0.5, 60.5);
     m_resid_before = fs->make<TH1F>("residBefore", "muon residuals before cut (cm)", 100, -20, 20);
     m_resid_after = fs->make<TH1F>("residAfter", "muon residuals after cut (cm)", 100, -20, 20);
   }
 }

AlignmentMuonHIPTrajectorySelector::~AlignmentMuonHIPTrajectorySelector ( )

override

Definition at line 108 of file AlignmentMuonHIPTrajectorySelector.cc.

108 {}

Member Function Documentation

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

overrideprivate

Definition at line 115 of file AlignmentMuonHIPTrajectorySelector.cc.

References TrajectoryMeasurement::backwardPredictedState(), edm::AssociationMap< Tag >::begin(), edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, MuonSubdetId::CSC, DEFINE_FWK_MODULE, MuonSubdetId::DT, edm::AssociationMap< Tag >::end(), TrajectoryMeasurement::forwardPredictedState(), edm::Event::getByLabel(), TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localPosition(), m_hists, m_input, m_maxMuonResidual, m_minPt, m_minTrackerDOF, m_pt, m_resid_after, m_resid_before, m_tracker_dof, m_tracker_forwardredchi2, eostools::move(), DetId::Muon, LocalTrajectoryError::positionError(), edm::Event::put(), TrajectoryMeasurement::recHit(), DetId::Tracker, PV3DBase< T, PVType, FrameType >::x(), hit::x, LocalError::xx(), LocalError::xy(), PV3DBase< T, PVType, FrameType >::y(), hit::y, and LocalError::yy().

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

                                                                                               {
   // input
   edm::Handle<TrajTrackAssociationCollection> originalTrajTrackMap;
   iEvent.getByLabel(m_input, originalTrajTrackMap);
 
   // output
   auto newTrajTrackMap = std::make_unique<TrajTrackAssociationCollection>();
 
   TrajectoryStateCombiner tsoscomb;
 
   for (TrajTrackAssociationCollection::const_iterator iPair = originalTrajTrackMap->begin();
        iPair != originalTrajTrackMap->end();
        ++iPair) {
     if (m_hists) {
       m_pt->Fill((*(*iPair).val).pt());
     }
 
     if ((*(*iPair).val).pt() > m_minPt) {
       std::vector<TrajectoryMeasurement> measurements = (*(*iPair).key).measurements();
 
       bool has_bad_residual = false;
 
       double tracker_forwardchi2 = 0.;
       double tracker_dof = 0.;
       for (std::vector<TrajectoryMeasurement>::const_iterator im = measurements.begin(); im != measurements.end();
            ++im) {
         const TrajectoryMeasurement meas = *im;
         auto hit = &(*meas.recHit());
         const DetId id = hit->geographicalId();
 
         if (hit->isValid() && id.det() == DetId::Tracker) {
           if (hit->dimension() == 1) {
             double residual = meas.forwardPredictedState().localPosition().x() - hit->localPosition().x();
             double error2 =
                 meas.forwardPredictedState().localError().positionError().xx() + hit->localPositionError().xx();
 
             tracker_forwardchi2 += residual * residual / error2;
             tracker_dof += 1.;
           } else if (hit->dimension() == 2) {
             double residualx = meas.forwardPredictedState().localPosition().x() - hit->localPosition().x();
             double residualy = meas.forwardPredictedState().localPosition().y() - hit->localPosition().y();
             double errorxx2 =
                 meas.forwardPredictedState().localError().positionError().xx() + hit->localPositionError().xx();
             double errorxy2 =
                 meas.forwardPredictedState().localError().positionError().xy() + hit->localPositionError().xy();
             double erroryy2 =
                 meas.forwardPredictedState().localError().positionError().yy() + hit->localPositionError().yy();
 
             tracker_forwardchi2 +=
                 (residualx * residualx + residualy * residualy) / (errorxx2 + 2. * errorxy2 + erroryy2);
             tracker_dof += 2.;
           }
         }  // end if a tracker hit
 
         if (hit->isValid() && id.det() == DetId::Muon &&
             (id.subdetId() == MuonSubdetId::DT || id.subdetId() == MuonSubdetId::CSC)) {
           TrajectoryStateOnSurface tsosc =
               tsoscomb.combine(meas.forwardPredictedState(), meas.backwardPredictedState());
           double residual = tsosc.localPosition().x() - hit->localPosition().x();
           m_resid_before->Fill(residual);
           if (fabs(residual) > m_maxMuonResidual) {
             has_bad_residual = true;
           }
         }  // end if a muon hit
       }
       tracker_dof -= 5.;
       double tracker_forwardredchi2 = tracker_forwardchi2 / tracker_dof;
 
       if (m_hists) {
         m_tracker_forwardredchi2->Fill(tracker_forwardredchi2);
         m_tracker_dof->Fill(tracker_dof);
 
         for (std::vector<TrajectoryMeasurement>::const_iterator im = measurements.begin(); im != measurements.end();
              ++im) {
           const TrajectoryMeasurement meas = *im;
           auto hit = &(*meas.recHit());
           const DetId id = hit->geographicalId();
 
           if (!has_bad_residual) {
             if (hit->isValid() && id.det() == DetId::Muon &&
                 (id.subdetId() == MuonSubdetId::DT || id.subdetId() == MuonSubdetId::CSC)) {
               TrajectoryStateOnSurface tsosc =
                   tsoscomb.combine(meas.forwardPredictedState(), meas.backwardPredictedState());
               double residual = tsosc.localPosition().x() - hit->localPosition().x();
               m_resid_after->Fill(residual);
             }
           }  // end if residuals pass cut
         }    // end second loop over hits
       }      // end if filling histograms
 
       if (tracker_forwardredchi2 < m_maxTrackerForwardRedChi2 && tracker_dof >= m_minTrackerDOF && !has_bad_residual) {
         newTrajTrackMap->insert((*iPair).key, (*iPair).val);
       }  // end if passes tracker cuts
     }    // end if passes pT cut
   }      // end loop over original trajTrackMap
 
   // put it in the Event
   iEvent.put(std::move(newTrajTrackMap));
 }