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

Inheritance diagram for AlignmentMuonHIPTrajectorySelector:

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

	~AlignmentMuonHIPTrajectorySelector () override=default

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 Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
const bool	m_hists

const edm::InputTag	m_input

const double	m_maxMuonResidual

const double	m_maxTrackerForwardRedChi2

const double	m_minPt

const int	m_minTrackerDOF

TH1F *	m_pt

TH1F *	m_resid_after

TH1F *	m_resid_before

TH1F *	m_tracker_dof

TH1F *	m_tracker_forwardredchi2

const edm::EDGetTokenT< TrajTrackAssociationCollection >	mapToken_

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

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

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

Definition at line 55 of file AlignmentMuonHIPTrajectorySelector.cc.

Constructor & Destructor Documentation

◆ AlignmentMuonHIPTrajectorySelector()

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

explicit

Definition at line 89 of file AlignmentMuonHIPTrajectorySelector.cc.

References make_classfiles::fs, m_hists, m_pt, m_resid_after, m_resid_before, m_tracker_dof, and m_tracker_forwardredchi2.

     : 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")),
       mapToken_(consumes<TrajTrackAssociationCollection>(m_input)),
       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::~AlignmentMuonHIPTrajectorySelector ( )

overridedefault

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 116 of file AlignmentMuonHIPTrajectorySelector.cc.

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

                                                                                                     {
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

◆ produce()

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

overrideprivate

Definition at line 123 of file AlignmentMuonHIPTrajectorySelector.cc.

References TrajectoryMeasurement::backwardPredictedState(), edm::AssociationMap< Tag >::begin(), MuonSubdetId::CSC, MuonSubdetId::DT, edm::AssociationMap< Tag >::end(), TrajectoryMeasurement::forwardPredictedState(), iEvent, TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localPosition(), m_hists, m_maxMuonResidual, m_minPt, m_minTrackerDOF, m_pt, m_resid_after, m_resid_before, m_tracker_dof, m_tracker_forwardredchi2, mapToken_, eostools::move(), DetId::Muon, LocalTrajectoryError::positionError(), 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().

                                                                                               {
   // input
   const edm::Handle<TrajTrackAssociationCollection>& originalTrajTrackMap = iEvent.getHandle(mapToken_);
 
   // 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));
 }