MuonTrackAnalyzer Class Reference

#include <MuonTrackAnalyzer.h>

Inheritance diagram for MuonTrackAnalyzer:

Public Types
enum	EtaRange { all, barrel, endcap }
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore
typedef dqm::reco::MonitorElement	MonitorElement
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
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 Member Functions
void	analyze (const edm::Event &event, const edm::EventSetup &eventSetup) override
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
	MuonTrackAnalyzer (const edm::ParameterSet &pset)
	Constructor. More...
void	seedsAnalysis (const edm::Event &event, const edm::EventSetup &eventSetup, edm::Handle< edm::SimTrackContainer > simTracks)
void	tracksAnalysis (const edm::Event &event, const edm::EventSetup &eventSetup, edm::Handle< edm::SimTrackContainer > simTracks)
	~MuonTrackAnalyzer () override
	Destructor. More...
Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final
void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final
void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer ()
void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
void	endRun (edm::Run const &run, edm::EventSetup const &setup) final
virtual bool	getCanSaveByLumi ()
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
bool	checkMuonSimHitPresence (const edm::Event &event, edm::Handle< edm::SimTrackContainer > simTracks)
void	fillPlots (const edm::Event &event, edm::Handle< edm::SimTrackContainer > &simTracks)
void	fillPlots (FreeTrajectoryState &recoFTS, SimTrack &simTrack, HTrack *histo, MuonPatternRecoDumper &debug)
void	fillPlots (reco::TransientTrack &track, SimTrack &simTrack)
void	fillPlots (TrajectoryStateOnSurface &recoTSOS, SimTrack &simState, HTrack *, MuonPatternRecoDumper &)
TrajectoryStateOnSurface	getSeedTSOS (const TrajectorySeed &seed)
std::pair< SimTrack, double >	getSimTrack (TrajectoryStateOnSurface &tsos, edm::Handle< edm::SimTrackContainer > simTracks)
bool	isInTheAcceptance (double eta)

Private Attributes
DQMStore *	dbe_
std::string	dirName_
bool	doSeedsAnalysis
bool	doTracksAnalysis
MonitorElement *	hChargeVsEta
MonitorElement *	hChargeVsPt
MonitorElement *	hChi2
MonitorElement *	hChi2Norm
MonitorElement *	hChi2NormVsEta
MonitorElement *	hChi2Prob
MonitorElement *	hChi2ProbVsEta
MonitorElement *	hChi2VsEta
MonitorElement *	hDeltaPt_In_Out_VsEta
MonitorElement *	hDeltaPtVsEta
MonitorElement *	hDof
MonitorElement *	hDofVsEta
MonitorElement *	hHitsPerTrack
MonitorElement *	hHitsPerTrackVsEta
MonitorElement *	hNumberOfTracks
MonitorElement *	hNumberOfTracksVsEta
MonitorElement *	hPtRecVsPtGen
HTrack *	hRecoSeedInner
HTrack *	hRecoSeedPCA
HTrack *	hRecoTracksInner
HTrack *	hRecoTracksOuter
HTrack *	hRecoTracksPCA
HTrackVariables *	hSimTracks
int	numberOfRecTracks
int	numberOfSimTracks
std::string	out
edm::ParameterSet	pset
std::string	subsystemname_
edm::InputTag	theCSCSimHitLabel
edm::EDGetTokenT< std::vector< PSimHit > >	theCSCSimHitToken
edm::InputTag	theDTSimHitLabel
edm::EDGetTokenT< std::vector< PSimHit > >	theDTSimHitToken
EtaRange	theEtaRange
edm::InputTag	theRPCSimHitLabel
edm::EDGetTokenT< std::vector< PSimHit > >	theRPCSimHitToken
std::string	theSeedPropagatorName
edm::InputTag	theSeedsLabel
edm::EDGetTokenT< TrajectorySeedCollection >	theSeedsToken
MuonServiceProxy *	theService
edm::InputTag	theSimTracksLabel
edm::EDGetTokenT< edm::SimTrackContainer >	theSimTracksToken
edm::InputTag	theTracksLabel
edm::EDGetTokenT< reco::TrackCollection >	theTracksToken
MuonUpdatorAtVertex *	theUpdator

Additional Inherited Members
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)
static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)
Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const
Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_
edm::EDPutTokenT< DQMToken >	runToken_
unsigned int	streamId_

Detailed Description

Analyzer of the Muon tracks

Author

R. Bellan - INFN Torino ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Analyzer of the StandAlone muon tracks

Author

R. Bellan - INFN Torino ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Definition at line 51 of file MuonTrackAnalyzer.h.

Member Enumeration Documentation

EtaRange

enum MuonTrackAnalyzer::EtaRange

Enumerator
all
barrel
endcap

Definition at line 53 of file MuonTrackAnalyzer.h.

{ all, barrel, endcap };

Constructor & Destructor Documentation

MuonTrackAnalyzer()

MuonTrackAnalyzer::MuonTrackAnalyzer

(

const edm::ParameterSet &

pset

)

Constructor.

Definition at line 41 of file MuonTrackAnalyzer.cc.

                                                           {
  // service parameters
  pset = ps;
  ParameterSet serviceParameters = pset.getParameter<ParameterSet>("ServiceParameters");
  // the services
  theService = new MuonServiceProxy(serviceParameters, consumesCollector());
 
  theSimTracksLabel = edm::InputTag("g4SimHits");
  theSimTracksToken = consumes<edm::SimTrackContainer>(theSimTracksLabel);
 
  theTracksLabel = pset.getParameter<InputTag>("Tracks");
  theTracksToken = consumes<reco::TrackCollection>(theTracksLabel);
  doTracksAnalysis = pset.getUntrackedParameter<bool>("DoTracksAnalysis", true);
 
  doSeedsAnalysis = pset.getUntrackedParameter<bool>("DoSeedsAnalysis", false);
  if (doSeedsAnalysis) {
    theSeedsLabel = pset.getParameter<InputTag>("MuonSeed");
    theSeedsToken = consumes<TrajectorySeedCollection>(theSeedsLabel);
    ParameterSet updatorPar = pset.getParameter<ParameterSet>("MuonUpdatorAtVertexParameters");
    theSeedPropagatorName = updatorPar.getParameter<string>("Propagator");
 
    theUpdator = new MuonUpdatorAtVertex(updatorPar, theService);
  }
 
  theCSCSimHitLabel = pset.getParameter<InputTag>("CSCSimHit");
  theDTSimHitLabel = pset.getParameter<InputTag>("DTSimHit");
  theRPCSimHitLabel = pset.getParameter<InputTag>("RPCSimHit");
  theCSCSimHitToken = consumes<std::vector<PSimHit> >(theCSCSimHitLabel);
  theDTSimHitToken = consumes<std::vector<PSimHit> >(theDTSimHitLabel);
  theRPCSimHitToken = consumes<std::vector<PSimHit> >(theRPCSimHitLabel);
 
  theEtaRange = (EtaRange)pset.getParameter<int>("EtaRange");
 
  // number of sim tracks
  numberOfSimTracks = 0;
  // number of reco tracks
  numberOfRecTracks = 0;
 
  dbe_ = edm::Service<DQMStore>().operator->();
  out = pset.getUntrackedParameter<string>("rootFileName");
  dirName_ = pset.getUntrackedParameter<std::string>("dirName");
  subsystemname_ = pset.getUntrackedParameter<std::string>("subSystemFolder", "YourSubsystem");
}

References dbe_, MuonAnalyzers_cfi::EtaRange, edm::ParameterSet::getParameter(), HLT_2018_cff::InputTag, MuonServiceProxy_cff::MuonServiceProxy, MuonUpdatorAtVertex_cff::MuonUpdatorAtVertex, MillePedeFileConverter_cfg::out, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

~MuonTrackAnalyzer()

MuonTrackAnalyzer::~MuonTrackAnalyzer ( )

override

Destructor.

Definition at line 86 of file MuonTrackAnalyzer.cc.

                                      {
  if (theService)
    delete theService;
}

Member Function Documentation

analyze()

void MuonTrackAnalyzer::analyze ( const edm::Event &  event, const edm::EventSetup &  eventSetup  )

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 170 of file MuonTrackAnalyzer.cc.

                                                                                {
  LogDebug("MuonTrackAnalyzer") << "Run: " << event.id().run() << " Event: " << event.id().event();
 
  // Update the services
  theService->update(eventSetup);
 
  Handle<SimTrackContainer> simTracks;
  event.getByToken(theSimTracksToken, simTracks);
  fillPlots(event, simTracks);
 
  if (doTracksAnalysis)
    tracksAnalysis(event, eventSetup, simTracks);
 
  if (doSeedsAnalysis)
    seedsAnalysis(event, eventSetup, simTracks);
}

References LogDebug, and TrackCandidateProducer_cfi::simTracks.

bookHistograms()

void MuonTrackAnalyzer::bookHistograms ( DQMStore::IBooker &  ibooker, edm::Run const &  iRun, edm::EventSetup const &    )

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 91 of file MuonTrackAnalyzer.cc.

                                                                {
  ibooker.cd();
 
  InputTag algo = theTracksLabel;
  string dirName = dirName_;
  if (!algo.process().empty())
    dirName += algo.process() + "_";
  if (!algo.label().empty())
    dirName += algo.label() + "_";
  if (!algo.instance().empty())
    dirName += algo.instance() + "";
  if (dirName.find("Tracks") < dirName.length()) {
    dirName.replace(dirName.find("Tracks"), 6, "");
  }
  std::replace(dirName.begin(), dirName.end(), ':', '_');
  ibooker.setCurrentFolder(dirName);
 
  //ibooker.goUp();
  std::string simName = dirName;
  simName += "/SimTracks";
  hSimTracks = new HTrackVariables(ibooker, simName, "SimTracks");
 
  ibooker.cd();
  ibooker.setCurrentFolder(dirName);
 
  // Create the root file
  //theFile = new TFile(theRootFileName.c_str(), "RECREATE");
 
  if (doSeedsAnalysis) {
    ibooker.cd();
    ibooker.setCurrentFolder(dirName);
    hRecoSeedInner = new HTrack(ibooker, dirName, "RecoSeed", "Inner");
    hRecoSeedPCA = new HTrack(ibooker, dirName, "RecoSeed", "PCA");
  }
 
  if (doTracksAnalysis) {
    ibooker.cd();
    ibooker.setCurrentFolder(dirName);
    hRecoTracksPCA = new HTrack(ibooker, dirName, "RecoTracks", "PCA");
    hRecoTracksInner = new HTrack(ibooker, dirName, "RecoTracks", "Inner");
    hRecoTracksOuter = new HTrack(ibooker, dirName, "RecoTracks", "Outer");
 
    ibooker.cd();
    ibooker.setCurrentFolder(dirName);
 
    // General Histos
 
    hChi2 = ibooker.book1D("chi2", "#chi^2", 200, 0, 200);
    hChi2VsEta = ibooker.book2D("chi2VsEta", "#chi^2 VS #eta", 120, -3., 3., 200, 0, 200);
 
    hChi2Norm = ibooker.book1D("chi2Norm", "Normalized #chi^2", 400, 0, 100);
    hChi2NormVsEta = ibooker.book2D("chi2NormVsEta", "Normalized #chi^2 VS #eta", 120, -3., 3., 400, 0, 100);
 
    hHitsPerTrack = ibooker.book1D("HitsPerTrack", "Number of hits per track", 55, 0, 55);
    hHitsPerTrackVsEta =
        ibooker.book2D("HitsPerTrackVsEta", "Number of hits per track VS #eta", 120, -3., 3., 55, 0, 55);
 
    hDof = ibooker.book1D("dof", "Number of Degree of Freedom", 55, 0, 55);
    hDofVsEta = ibooker.book2D("dofVsEta", "Number of Degree of Freedom VS #eta", 120, -3., 3., 55, 0, 55);
 
    hChi2Prob = ibooker.book1D("chi2Prob", "#chi^2 probability", 200, 0, 1);
    hChi2ProbVsEta = ibooker.book2D("chi2ProbVsEta", "#chi^2 probability VS #eta", 120, -3., 3., 200, 0, 1);
 
    hNumberOfTracks = ibooker.book1D("NumberOfTracks", "Number of reconstructed tracks per event", 200, 0, 200);
    hNumberOfTracksVsEta = ibooker.book2D(
        "NumberOfTracksVsEta", "Number of reconstructed tracks per event VS #eta", 120, -3., 3., 10, 0, 10);
 
    hChargeVsEta = ibooker.book2D("ChargeVsEta", "Charge vs #eta gen", 120, -3., 3., 4, -2., 2.);
    hChargeVsPt = ibooker.book2D("ChargeVsPt", "Charge vs P_{T} gen", 250, 0, 200, 4, -2., 2.);
    hPtRecVsPtGen = ibooker.book2D("PtRecVsPtGen", "P_{T} rec vs P_{T} gen", 250, 0, 200, 250, 0, 200);
 
    hDeltaPtVsEta = ibooker.book2D("DeltaPtVsEta", "#Delta P_{t} vs #eta gen", 120, -3., 3., 500, -250., 250.);
    hDeltaPt_In_Out_VsEta =
        ibooker.book2D("DeltaPt_In_Out_VsEta_", "P^{in}_{t} - P^{out}_{t} vs #eta gen", 120, -3., 3., 500, -250., 250.);
  }
}

References dqm::implementation::IBooker::book1D(), dqm::implementation::IBooker::book2D(), dqm::implementation::NavigatorBase::cd(), TrackerOfflineValidation_Dqm_cff::dirName, python.rootplot.root2matplotlib::replace(), dqm::implementation::NavigatorBase::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

checkMuonSimHitPresence()

bool MuonTrackAnalyzer::checkMuonSimHitPresence ( const edm::Event &  event, edm::Handle< edm::SimTrackContainer >  simTracks  )

private

Definition at line 394 of file MuonTrackAnalyzer.cc.

                                                                                                             {
  // Get the SimHit collection from the event
  Handle<PSimHitContainer> dtSimHits;
  event.getByToken(theDTSimHitToken, dtSimHits);
 
  Handle<PSimHitContainer> cscSimHits;
  event.getByToken(theCSCSimHitToken, cscSimHits);
 
  Handle<PSimHitContainer> rpcSimHits;
  event.getByToken(theRPCSimHitToken, rpcSimHits);
 
  map<unsigned int, vector<const PSimHit *> > mapOfMuonSimHits;
 
  for (PSimHitContainer::const_iterator simhit = dtSimHits->begin(); simhit != dtSimHits->end(); ++simhit) {
    if (abs(simhit->particleType()) != 13)
      continue;
    mapOfMuonSimHits[simhit->trackId()].push_back(&*simhit);
  }
 
  for (PSimHitContainer::const_iterator simhit = cscSimHits->begin(); simhit != cscSimHits->end(); ++simhit) {
    if (abs(simhit->particleType()) != 13)
      continue;
    mapOfMuonSimHits[simhit->trackId()].push_back(&*simhit);
  }
 
  for (PSimHitContainer::const_iterator simhit = rpcSimHits->begin(); simhit != rpcSimHits->end(); ++simhit) {
    if (abs(simhit->particleType()) != 13)
      continue;
    mapOfMuonSimHits[simhit->trackId()].push_back(&*simhit);
  }
 
  bool presence = false;
 
  for (SimTrackContainer::const_iterator simTrack = simTracks->begin(); simTrack != simTracks->end(); ++simTrack) {
    if (abs(simTrack->type()) != 13)
      continue;
 
    map<unsigned int, vector<const PSimHit *> >::const_iterator mapIterator =
        mapOfMuonSimHits.find(simTrack->trackId());
 
    if (mapIterator != mapOfMuonSimHits.end())
      presence = true;
  }
 
  return presence;
}

References funct::abs(), muonSimHitMatcherPSet::simTrack, and TrackCandidateProducer_cfi::simTracks.

fillPlots() [1/4]

void MuonTrackAnalyzer::fillPlots ( const edm::Event &  event, edm::Handle< edm::SimTrackContainer > &  simTracks  )

private

Definition at line 263 of file MuonTrackAnalyzer.cc.

                                                                                                {
  if (!checkMuonSimHitPresence(event, simTracks))
    return;
 
  // Loop over the Sim tracks
  SimTrackContainer::const_iterator simTrack;
  LogTrace("MuonTrackAnalyzer") << "Simulated tracks: " << simTracks->size() << endl;
 
  for (simTrack = simTracks->begin(); simTrack != simTracks->end(); ++simTrack)
    if (abs((*simTrack).type()) == 13) {
      if (!isInTheAcceptance((*simTrack).momentum().eta()))
        continue;  // FIXME!!
 
      numberOfSimTracks++;
 
      LogTrace("MuonTrackAnalyzer") << "Simualted muon:" << endl;
      LogTrace("MuonTrackAnalyzer") << "Sim pT: " << sqrt((*simTrack).momentum().perp2()) << endl;
      LogTrace("MuonTrackAnalyzer") << "Sim Eta: " << (*simTrack).momentum().eta() << endl;  // FIXME
 
      hSimTracks->Fill((*simTrack).momentum().mag(),
                       sqrt((*simTrack).momentum().perp2()),
                       (*simTrack).momentum().eta(),
                       (*simTrack).momentum().phi(),
                       -(*simTrack).type() / abs((*simTrack).type()));  // Double FIXME
      LogTrace("MuonTrackAnalyzer") << "hSimTracks filled" << endl;
    }
 
  LogTrace("MuonTrackAnalyzer") << endl;
}

References funct::abs(), LogTrace, muonSimHitMatcherPSet::simTrack, TrackCandidateProducer_cfi::simTracks, and mathSSE::sqrt().

fillPlots() [2/4]

void MuonTrackAnalyzer::fillPlots ( FreeTrajectoryState &  recoFTS, SimTrack &  simTrack, HTrack *  histo, MuonPatternRecoDumper &  debug  )

private

Definition at line 324 of file MuonTrackAnalyzer.cc.

                                                                {
  LogTrace("MuonTrackAnalyzer") << debug.dumpFTS(recoFTS) << endl;
  histo->Fill(recoFTS);
 
  GlobalVector ftsVect = recoFTS.momentum();
  math::XYZVectorD reco(ftsVect.x(), ftsVect.y(), ftsVect.z());
  double deltaRVal = deltaR<double>(reco.eta(), reco.phi(), simTrack.momentum().eta(), simTrack.momentum().phi());
  histo->FillDeltaR(deltaRVal);
 
  histo->computeResolutionAndPull(recoFTS, simTrack);
}

References debug, timingPdfMaker::histo, LogTrace, FreeTrajectoryState::momentum(), dt_dqm_sourceclient_common_cff::reco, muonSimHitMatcherPSet::simTrack, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

fillPlots() [3/4]

void MuonTrackAnalyzer::fillPlots ( reco::TransientTrack &  track, SimTrack &  simTrack  )

private

Definition at line 293 of file MuonTrackAnalyzer.cc.

                                                                               {
  LogTrace("MuonTrackAnalyzer") << "Analizer: New track, chi2: " << track.chi2() << " dof: " << track.ndof() << endl;
  hChi2->Fill(track.chi2());
  hDof->Fill(track.ndof());
  hChi2Norm->Fill(track.normalizedChi2());
  hHitsPerTrack->Fill(track.recHitsSize());
 
  hChi2Prob->Fill(ChiSquaredProbability(track.chi2(), track.ndof()));
 
  hChi2VsEta->Fill(simTrack.momentum().eta(), track.chi2());
  hChi2NormVsEta->Fill(simTrack.momentum().eta(), track.normalizedChi2());
  hChi2ProbVsEta->Fill(simTrack.momentum().eta(), ChiSquaredProbability(track.chi2(), track.ndof()));
  hHitsPerTrackVsEta->Fill(simTrack.momentum().eta(), track.recHitsSize());
  hDofVsEta->Fill(simTrack.momentum().eta(), track.ndof());
}

References ChiSquaredProbability(), LogTrace, muonSimHitMatcherPSet::simTrack, and HLT_2018_cff::track.

fillPlots() [4/4]

void MuonTrackAnalyzer::fillPlots ( TrajectoryStateOnSurface &  recoTSOS, SimTrack &  simState, HTrack *  histo, MuonPatternRecoDumper &  debug  )

private

Definition at line 309 of file MuonTrackAnalyzer.cc.

                                                                {
  LogTrace("MuonTrackAnalyzer") << debug.dumpTSOS(recoTSOS) << endl;
  histo->Fill(recoTSOS);
 
  GlobalVector tsosVect = recoTSOS.globalMomentum();
  math::XYZVectorD reco(tsosVect.x(), tsosVect.y(), tsosVect.z());
  double deltaRVal = deltaR<double>(reco.eta(), reco.phi(), simTrack.momentum().eta(), simTrack.momentum().phi());
  histo->FillDeltaR(deltaRVal);
 
  histo->computeResolutionAndPull(recoTSOS, simTrack);
}

References debug, TrajectoryStateOnSurface::globalMomentum(), timingPdfMaker::histo, LogTrace, dt_dqm_sourceclient_common_cff::reco, muonSimHitMatcherPSet::simTrack, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

getSeedTSOS()

TrajectoryStateOnSurface MuonTrackAnalyzer::getSeedTSOS ( const TrajectorySeed &  seed )

private

Definition at line 441 of file MuonTrackAnalyzer.cc.

                                                                                  {
  // Get the Trajectory State on Det (persistent version of a TSOS) from the seed
  PTrajectoryStateOnDet pTSOD = seed.startingState();
 
  // Transform it in a TrajectoryStateOnSurface
 
  DetId seedDetId(pTSOD.detId());
 
  const GeomDet *gdet = theService->trackingGeometry()->idToDet(seedDetId);
 
  TrajectoryStateOnSurface initialState =
      trajectoryStateTransform::transientState(pTSOD, &(gdet->surface()), &*theService->magneticField());
 
  // Get the layer on which the seed relies
  const DetLayer *initialLayer = theService->detLayerGeometry()->idToLayer(seedDetId);
 
  PropagationDirection detLayerOrder = oppositeToMomentum;
 
  // ask for compatible layers
  vector<const DetLayer *> detLayers;
  detLayers =
      theService->muonNavigationSchool()->compatibleLayers(*initialLayer, *initialState.freeState(), detLayerOrder);
 
  TrajectoryStateOnSurface result = initialState;
  if (!detLayers.empty()) {
    const DetLayer *finalLayer = detLayers.back();
    const TrajectoryStateOnSurface propagatedState =
        theService->propagator(theSeedPropagatorName)->propagate(initialState, finalLayer->surface());
    if (propagatedState.isValid())
      result = propagatedState;
  }
 
  return result;
}

References PTrajectoryStateOnDet::detId(), TrajectoryStateOnSurface::freeState(), TrajectoryStateOnSurface::isValid(), oppositeToMomentum, mps_fire::result, SurveyInfoScenario_cff::seed, GeometricSearchDet::surface(), and trajectoryStateTransform::transientState().

getSimTrack()

pair< SimTrack, double > MuonTrackAnalyzer::getSimTrack ( TrajectoryStateOnSurface &  tsos, edm::Handle< edm::SimTrackContainer >  simTracks  )

private

Definition at line 339 of file MuonTrackAnalyzer.cc.

                                                                                           {
  //   // Loop over the Sim tracks
  //   SimTrackContainer::const_iterator simTrack;
 
  //   SimTrack result;
  //   int mu=0;
  //   for (simTrack = simTracks->begin(); simTrack != simTracks->end(); ++simTrack)
  //     if (abs((*simTrack).type()) == 13) {
  //       result = *simTrack;
  //       ++mu;
  //     }
 
  //   if(mu != 1) LogTrace("MuonTrackAnalyzer") << "WARNING!! more than 1 simulated muon!!" <<endl;
  //   return result;
 
  // Loop over the Sim tracks
  SimTrackContainer::const_iterator simTrack;
 
  SimTrack result;
 
  double bestDeltaR = 10e5;
  for (simTrack = simTracks->begin(); simTrack != simTracks->end(); ++simTrack) {
    if (abs((*simTrack).type()) != 13)
      continue;
 
    //    double newDeltaR = tsos.globalMomentum().basicVector().deltaR(simTrack->momentum().vect());
    GlobalVector tsosVect = tsos.globalMomentum();
    math::XYZVectorD vect(tsosVect.x(), tsosVect.y(), tsosVect.z());
    double newDeltaR = deltaR<double>(vect.eta(), vect.phi(), simTrack->momentum().eta(), simTrack->momentum().phi());
 
    if (newDeltaR < bestDeltaR) {
      LogTrace("MuonTrackAnalyzer") << "Matching Track with DeltaR = " << newDeltaR << endl;
      bestDeltaR = newDeltaR;
      result = *simTrack;
    }
  }
  return pair<SimTrack, double>(result, bestDeltaR);
}

References funct::abs(), TrajectoryStateOnSurface::globalMomentum(), LogTrace, mps_fire::result, muonSimHitMatcherPSet::simTrack, TrackCandidateProducer_cfi::simTracks, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

isInTheAcceptance()

bool MuonTrackAnalyzer::isInTheAcceptance ( double  eta )

private

Definition at line 379 of file MuonTrackAnalyzer.cc.

                                                    {
  switch (theEtaRange) {
    case all:
      return (abs(eta) <= 2.4) ? true : false;
    case barrel:
      return (abs(eta) < 1.1) ? true : false;
    case endcap:
      return (abs(eta) >= 1.1 && abs(eta) <= 2.4) ? true : false;
    default: {
      LogTrace("MuonTrackAnalyzer") << "No correct Eta range selected!! " << endl;
      return false;
    }
  }
}

References funct::abs(), python.cmstools::all(), Reference_intrackfit_cff::barrel, makeMuonMisalignmentScenario::endcap, PVValHelper::eta, LogTrace, and funct::true.

seedsAnalysis()

void MuonTrackAnalyzer::seedsAnalysis	(	const edm::Event &	event,
		const edm::EventSetup &	eventSetup,
		edm::Handle< edm::SimTrackContainer >	simTracks
	)

Definition at line 187 of file MuonTrackAnalyzer.cc.

                                                                           {
  MuonPatternRecoDumper debug;
 
  // Get the RecTrack collection from the event
  Handle<TrajectorySeedCollection> seeds;
  event.getByToken(theSeedsToken, seeds);
 
  LogTrace("MuonTrackAnalyzer") << "Number of reconstructed seeds: " << seeds->size() << endl;
 
  for (TrajectorySeedCollection::const_iterator seed = seeds->begin(); seed != seeds->end(); ++seed) {
    TrajectoryStateOnSurface seedTSOS = getSeedTSOS(*seed);
    pair<SimTrack, double> sim = getSimTrack(seedTSOS, simTracks);
    fillPlots(seedTSOS, sim.first, hRecoSeedInner, debug);
 
    std::pair<bool, FreeTrajectoryState> propSeed = theUpdator->propagateToNominalLine(seedTSOS);
    if (propSeed.first)
      fillPlots(propSeed.second, sim.first, hRecoSeedPCA, debug);
    else
      LogTrace("MuonTrackAnalyzer") << "Error in seed propagation" << endl;
  }
}

References debug, LogTrace, SurveyInfoScenario_cff::seed, InitialStep_cff::seeds, and TrackCandidateProducer_cfi::simTracks.

tracksAnalysis()

void MuonTrackAnalyzer::tracksAnalysis	(	const edm::Event &	event,
		const edm::EventSetup &	eventSetup,
		edm::Handle< edm::SimTrackContainer >	simTracks
	)

Definition at line 211 of file MuonTrackAnalyzer.cc.

                                                                            {
  MuonPatternRecoDumper debug;
 
  // Get the RecTrack collection from the event
  Handle<reco::TrackCollection> tracks;
  event.getByToken(theTracksToken, tracks);
 
  LogTrace("MuonTrackAnalyzer") << "Reconstructed tracks: " << tracks->size() << endl;
  hNumberOfTracks->Fill(tracks->size());
 
  if (!tracks->empty())
    numberOfRecTracks++;
 
  // Loop over the Rec tracks
  for (reco::TrackCollection::const_iterator t = tracks->begin(); t != tracks->end(); ++t) {
    reco::TransientTrack track(*t, &*theService->magneticField(), theService->trackingGeometry());
 
    TrajectoryStateOnSurface outerTSOS = track.outermostMeasurementState();
    TrajectoryStateOnSurface innerTSOS = track.innermostMeasurementState();
    TrajectoryStateOnSurface pcaTSOS = track.impactPointState();
 
    pair<SimTrack, double> sim = getSimTrack(pcaTSOS, simTracks);
    SimTrack simTrack = sim.first;
    hNumberOfTracksVsEta->Fill(simTrack.momentum().eta(), tracks->size());
    fillPlots(track, simTrack);
 
    LogTrace("MuonTrackAnalyzer") << "State at the outer surface: " << endl;
    fillPlots(outerTSOS, simTrack, hRecoTracksOuter, debug);
 
    LogTrace("MuonTrackAnalyzer") << "State at the inner surface: " << endl;
    fillPlots(innerTSOS, simTrack, hRecoTracksInner, debug);
 
    LogTrace("MuonTrackAnalyzer") << "State at PCA: " << endl;
    fillPlots(pcaTSOS, simTrack, hRecoTracksPCA, debug);
 
    double deltaPt_in_out = innerTSOS.globalMomentum().perp() - outerTSOS.globalMomentum().perp();
    hDeltaPt_In_Out_VsEta->Fill(simTrack.momentum().eta(), deltaPt_in_out);
 
    double deltaPt_pca_sim = pcaTSOS.globalMomentum().perp() - sqrt(simTrack.momentum().Perp2());
    hDeltaPtVsEta->Fill(simTrack.momentum().eta(), deltaPt_pca_sim);
 
    hChargeVsEta->Fill(simTrack.momentum().eta(), pcaTSOS.charge());
 
    hChargeVsPt->Fill(sqrt(simTrack.momentum().perp2()), pcaTSOS.charge());
 
    hPtRecVsPtGen->Fill(sqrt(simTrack.momentum().perp2()), pcaTSOS.globalMomentum().perp());
  }
  LogTrace("MuonTrackAnalyzer") << "--------------------------------------------" << endl;
}

References TrajectoryStateOnSurface::charge(), debug, TrajectoryStateOnSurface::globalMomentum(), LogTrace, PV3DBase< T, PVType, FrameType >::perp(), muonSimHitMatcherPSet::simTrack, TrackCandidateProducer_cfi::simTracks, mathSSE::sqrt(), OrderedSet::t, HLT_2018_cff::track, and PDWG_EXOHSCP_cff::tracks.

Member Data Documentation

dbe_

DQMStore* MuonTrackAnalyzer::dbe_

private

Definition at line 89 of file MuonTrackAnalyzer.h.

dirName_

std::string MuonTrackAnalyzer::dirName_

private

Definition at line 90 of file MuonTrackAnalyzer.h.

doSeedsAnalysis

bool MuonTrackAnalyzer::doSeedsAnalysis

private

Definition at line 114 of file MuonTrackAnalyzer.h.

doTracksAnalysis

bool MuonTrackAnalyzer::doTracksAnalysis

private

Definition at line 113 of file MuonTrackAnalyzer.h.

hChargeVsEta

MonitorElement* MuonTrackAnalyzer::hChargeVsEta

private

Definition at line 129 of file MuonTrackAnalyzer.h.

hChargeVsPt

MonitorElement* MuonTrackAnalyzer::hChargeVsPt

private

Definition at line 130 of file MuonTrackAnalyzer.h.

hChi2

MonitorElement* MuonTrackAnalyzer::hChi2

private

Definition at line 121 of file MuonTrackAnalyzer.h.

hChi2Norm

MonitorElement* MuonTrackAnalyzer::hChi2Norm

private

Definition at line 122 of file MuonTrackAnalyzer.h.

hChi2NormVsEta

MonitorElement* MuonTrackAnalyzer::hChi2NormVsEta

private

Definition at line 134 of file MuonTrackAnalyzer.h.

hChi2Prob

MonitorElement* MuonTrackAnalyzer::hChi2Prob

private

Definition at line 125 of file MuonTrackAnalyzer.h.

hChi2ProbVsEta

MonitorElement* MuonTrackAnalyzer::hChi2ProbVsEta

private

Definition at line 137 of file MuonTrackAnalyzer.h.

hChi2VsEta

MonitorElement* MuonTrackAnalyzer::hChi2VsEta

private

Definition at line 133 of file MuonTrackAnalyzer.h.

hDeltaPt_In_Out_VsEta

MonitorElement* MuonTrackAnalyzer::hDeltaPt_In_Out_VsEta

private

Definition at line 139 of file MuonTrackAnalyzer.h.

hDeltaPtVsEta

MonitorElement* MuonTrackAnalyzer::hDeltaPtVsEta

private

Definition at line 138 of file MuonTrackAnalyzer.h.

hDof

MonitorElement* MuonTrackAnalyzer::hDof

private

Definition at line 124 of file MuonTrackAnalyzer.h.

hDofVsEta

MonitorElement* MuonTrackAnalyzer::hDofVsEta

private

Definition at line 136 of file MuonTrackAnalyzer.h.

hHitsPerTrack

MonitorElement* MuonTrackAnalyzer::hHitsPerTrack

private

Definition at line 123 of file MuonTrackAnalyzer.h.

hHitsPerTrackVsEta

MonitorElement* MuonTrackAnalyzer::hHitsPerTrackVsEta

private

Definition at line 135 of file MuonTrackAnalyzer.h.

hNumberOfTracks

MonitorElement* MuonTrackAnalyzer::hNumberOfTracks

private

Definition at line 127 of file MuonTrackAnalyzer.h.

hNumberOfTracksVsEta

MonitorElement* MuonTrackAnalyzer::hNumberOfTracksVsEta

private

Definition at line 128 of file MuonTrackAnalyzer.h.

hPtRecVsPtGen

MonitorElement* MuonTrackAnalyzer::hPtRecVsPtGen

private

Definition at line 131 of file MuonTrackAnalyzer.h.

hRecoSeedInner

HTrack* MuonTrackAnalyzer::hRecoSeedInner

private

Definition at line 143 of file MuonTrackAnalyzer.h.

hRecoSeedPCA

HTrack* MuonTrackAnalyzer::hRecoSeedPCA

private

Definition at line 144 of file MuonTrackAnalyzer.h.

hRecoTracksInner

HTrack* MuonTrackAnalyzer::hRecoTracksInner

private

Definition at line 146 of file MuonTrackAnalyzer.h.

hRecoTracksOuter

HTrack* MuonTrackAnalyzer::hRecoTracksOuter

private

Definition at line 147 of file MuonTrackAnalyzer.h.

hRecoTracksPCA

HTrack* MuonTrackAnalyzer::hRecoTracksPCA

private

Definition at line 145 of file MuonTrackAnalyzer.h.

hSimTracks

HTrackVariables* MuonTrackAnalyzer::hSimTracks

private

Definition at line 141 of file MuonTrackAnalyzer.h.

numberOfRecTracks

int MuonTrackAnalyzer::numberOfRecTracks

private

Definition at line 151 of file MuonTrackAnalyzer.h.

numberOfSimTracks

int MuonTrackAnalyzer::numberOfSimTracks

private

Definition at line 150 of file MuonTrackAnalyzer.h.

out

std::string MuonTrackAnalyzer::out

private

Definition at line 92 of file MuonTrackAnalyzer.h.

pset

edm::ParameterSet MuonTrackAnalyzer::pset

private

Definition at line 94 of file MuonTrackAnalyzer.h.

subsystemname_

std::string MuonTrackAnalyzer::subsystemname_

private

Definition at line 93 of file MuonTrackAnalyzer.h.

theCSCSimHitLabel

edm::InputTag MuonTrackAnalyzer::theCSCSimHitLabel

private

Definition at line 102 of file MuonTrackAnalyzer.h.

theCSCSimHitToken

edm::EDGetTokenT<std::vector<PSimHit> > MuonTrackAnalyzer::theCSCSimHitToken

private

Definition at line 109 of file MuonTrackAnalyzer.h.

theDTSimHitLabel

edm::InputTag MuonTrackAnalyzer::theDTSimHitLabel

private

Definition at line 103 of file MuonTrackAnalyzer.h.

theDTSimHitToken

edm::EDGetTokenT<std::vector<PSimHit> > MuonTrackAnalyzer::theDTSimHitToken

private

Definition at line 110 of file MuonTrackAnalyzer.h.

theEtaRange

EtaRange MuonTrackAnalyzer::theEtaRange

private

Definition at line 97 of file MuonTrackAnalyzer.h.

theRPCSimHitLabel

edm::InputTag MuonTrackAnalyzer::theRPCSimHitLabel

private

Definition at line 104 of file MuonTrackAnalyzer.h.

theRPCSimHitToken

edm::EDGetTokenT<std::vector<PSimHit> > MuonTrackAnalyzer::theRPCSimHitToken

private

Definition at line 111 of file MuonTrackAnalyzer.h.

theSeedPropagatorName

std::string MuonTrackAnalyzer::theSeedPropagatorName

private

Definition at line 115 of file MuonTrackAnalyzer.h.

theSeedsLabel

edm::InputTag MuonTrackAnalyzer::theSeedsLabel

private

Definition at line 100 of file MuonTrackAnalyzer.h.

theSeedsToken

edm::EDGetTokenT<TrajectorySeedCollection> MuonTrackAnalyzer::theSeedsToken

private

Definition at line 107 of file MuonTrackAnalyzer.h.

theService

MuonServiceProxy* MuonTrackAnalyzer::theService

private

Definition at line 117 of file MuonTrackAnalyzer.h.

theSimTracksLabel

edm::InputTag MuonTrackAnalyzer::theSimTracksLabel

private

Definition at line 99 of file MuonTrackAnalyzer.h.

theSimTracksToken

edm::EDGetTokenT<edm::SimTrackContainer> MuonTrackAnalyzer::theSimTracksToken

private

Definition at line 106 of file MuonTrackAnalyzer.h.

theTracksLabel

edm::InputTag MuonTrackAnalyzer::theTracksLabel

private

Definition at line 101 of file MuonTrackAnalyzer.h.

theTracksToken

edm::EDGetTokenT<reco::TrackCollection> MuonTrackAnalyzer::theTracksToken

private

Definition at line 108 of file MuonTrackAnalyzer.h.

theUpdator

MuonUpdatorAtVertex* MuonTrackAnalyzer::theUpdator

private

Definition at line 118 of file MuonTrackAnalyzer.h.