#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::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

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::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 54 of file AlignmentMuonHIPTrajectorySelector.cc.

Constructor & Destructor Documentation

◆ AlignmentMuonHIPTrajectorySelector()

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

explicit

Definition at line 85 of file AlignmentMuonHIPTrajectorySelector.cc.

References compareTotals::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")),
       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 ( )

override

Definition at line 108 of file AlignmentMuonHIPTrajectorySelector.cc.

108 {}

Member Function Documentation

◆ produce()

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, MuonSubdetId::DT, edm::AssociationMap< Tag >::end(), TrajectoryMeasurement::forwardPredictedState(), iEvent, 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(), 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
   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));
 }