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

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
	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
bool	checkMuonSimHitPresence (const edm::Event &event, edm::Handle< edm::SimTrackContainer > simTracks)
void	fillPlots (const edm::Event &event, edm::Handle< edm::SimTrackContainer > &simTracks)
void	fillPlots (reco::TransientTrack &track, SimTrack &simTrack)
void	fillPlots (TrajectoryStateOnSurface &recoTSOS, SimTrack &simState, HTrack *, MuonPatternRecoDumper &)
void	fillPlots (FreeTrajectoryState &recoFTS, SimTrack &simTrack, HTrack *histo, MuonPatternRecoDumper &debug)
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 50 of file MuonTrackAnalyzer.h.

Member Enumeration Documentation

EtaRange

enum MuonTrackAnalyzer::EtaRange

Enumerator
all
barrel
endcap

Definition at line 52 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.

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

                                                           {
  // 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");
}

~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.

References options_cfi::eventSetup, LogDebug, and TrackCandidateProducer_cfi::simTracks.

                                                                                {
  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);
}

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.

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.

                                                                {
  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.);
  }
}

checkMuonSimHitPresence()

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

private

Definition at line 394 of file MuonTrackAnalyzer.cc.

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

                                                                                                             {
  // 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;
}

fillPlots() [1/4]

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

private

Definition at line 263 of file MuonTrackAnalyzer.cc.

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

                                                                                                {
  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;
}

fillPlots() [2/4]

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

private

Definition at line 293 of file MuonTrackAnalyzer.cc.

References ChiSquaredProbability(), LogTrace, cscDigiValidation_cfi::simTrack, and HLT_2024v14_cff::track.

                                                                               {
  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());
}

fillPlots() [3/4]

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

private

Definition at line 309 of file MuonTrackAnalyzer.cc.

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

                                                                {
  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);
}

fillPlots() [4/4]

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

private

Definition at line 324 of file MuonTrackAnalyzer.cc.

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

                                                                {
  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);
}

getSeedTSOS()

TrajectoryStateOnSurface MuonTrackAnalyzer::getSeedTSOS ( const TrajectorySeed &  seed )

private

Definition at line 441 of file MuonTrackAnalyzer.cc.

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

                                                                                  {
  // 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;
}

getSimTrack()

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

private

Definition at line 339 of file MuonTrackAnalyzer.cc.

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

                                                                                           {
  //   // 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);
}

isInTheAcceptance()

bool MuonTrackAnalyzer::isInTheAcceptance ( double  eta )

private

Definition at line 379 of file MuonTrackAnalyzer.cc.

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

                                                    {
  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;
    }
  }
}

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.

References debug, LogTrace, fileCollector::seed, HLT_2024v14_cff::seeds, and TrackCandidateProducer_cfi::simTracks.

                                                                           {
  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;
  }
}

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.

References TrajectoryStateOnSurface::charge(), debug, TrajectoryStateOnSurface::globalMomentum(), LogTrace, PV3DBase< T, PVType, FrameType >::perp(), cscDigiValidation_cfi::simTrack, TrackCandidateProducer_cfi::simTracks, mathSSE::sqrt(), submitPVValidationJobs::t, HLT_2024v14_cff::track, and DiMuonV_cfg::tracks.

                                                                            {
  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;
}

Member Data Documentation

dbe_

DQMStore* MuonTrackAnalyzer::dbe_

private

Definition at line 88 of file MuonTrackAnalyzer.h.

dirName_

std::string MuonTrackAnalyzer::dirName_

private

Definition at line 89 of file MuonTrackAnalyzer.h.

doSeedsAnalysis

bool MuonTrackAnalyzer::doSeedsAnalysis

private

Definition at line 113 of file MuonTrackAnalyzer.h.

doTracksAnalysis

bool MuonTrackAnalyzer::doTracksAnalysis

private

Definition at line 112 of file MuonTrackAnalyzer.h.

hChargeVsEta

MonitorElement* MuonTrackAnalyzer::hChargeVsEta

private

Definition at line 128 of file MuonTrackAnalyzer.h.

hChargeVsPt

MonitorElement* MuonTrackAnalyzer::hChargeVsPt

private

Definition at line 129 of file MuonTrackAnalyzer.h.

hChi2

MonitorElement* MuonTrackAnalyzer::hChi2

private

Definition at line 120 of file MuonTrackAnalyzer.h.

hChi2Norm

MonitorElement* MuonTrackAnalyzer::hChi2Norm

private

Definition at line 121 of file MuonTrackAnalyzer.h.

hChi2NormVsEta

MonitorElement* MuonTrackAnalyzer::hChi2NormVsEta

private

Definition at line 133 of file MuonTrackAnalyzer.h.

hChi2Prob

MonitorElement* MuonTrackAnalyzer::hChi2Prob

private

Definition at line 124 of file MuonTrackAnalyzer.h.

hChi2ProbVsEta

MonitorElement* MuonTrackAnalyzer::hChi2ProbVsEta

private

Definition at line 136 of file MuonTrackAnalyzer.h.

hChi2VsEta

MonitorElement* MuonTrackAnalyzer::hChi2VsEta

private

Definition at line 132 of file MuonTrackAnalyzer.h.

hDeltaPt_In_Out_VsEta

MonitorElement* MuonTrackAnalyzer::hDeltaPt_In_Out_VsEta

private

Definition at line 138 of file MuonTrackAnalyzer.h.

hDeltaPtVsEta

MonitorElement* MuonTrackAnalyzer::hDeltaPtVsEta

private

Definition at line 137 of file MuonTrackAnalyzer.h.

hDof

MonitorElement* MuonTrackAnalyzer::hDof

private

Definition at line 123 of file MuonTrackAnalyzer.h.

hDofVsEta

MonitorElement* MuonTrackAnalyzer::hDofVsEta

private

Definition at line 135 of file MuonTrackAnalyzer.h.

hHitsPerTrack

MonitorElement* MuonTrackAnalyzer::hHitsPerTrack

private

Definition at line 122 of file MuonTrackAnalyzer.h.

hHitsPerTrackVsEta

MonitorElement* MuonTrackAnalyzer::hHitsPerTrackVsEta

private

Definition at line 134 of file MuonTrackAnalyzer.h.

hNumberOfTracks

MonitorElement* MuonTrackAnalyzer::hNumberOfTracks

private

Definition at line 126 of file MuonTrackAnalyzer.h.

hNumberOfTracksVsEta

MonitorElement* MuonTrackAnalyzer::hNumberOfTracksVsEta

private

Definition at line 127 of file MuonTrackAnalyzer.h.

hPtRecVsPtGen

MonitorElement* MuonTrackAnalyzer::hPtRecVsPtGen

private

Definition at line 130 of file MuonTrackAnalyzer.h.

hRecoSeedInner

HTrack* MuonTrackAnalyzer::hRecoSeedInner

private

Definition at line 142 of file MuonTrackAnalyzer.h.

hRecoSeedPCA

HTrack* MuonTrackAnalyzer::hRecoSeedPCA

private

Definition at line 143 of file MuonTrackAnalyzer.h.

hRecoTracksInner

HTrack* MuonTrackAnalyzer::hRecoTracksInner

private

Definition at line 145 of file MuonTrackAnalyzer.h.

hRecoTracksOuter

HTrack* MuonTrackAnalyzer::hRecoTracksOuter

private

Definition at line 146 of file MuonTrackAnalyzer.h.

hRecoTracksPCA

HTrack* MuonTrackAnalyzer::hRecoTracksPCA

private

Definition at line 144 of file MuonTrackAnalyzer.h.

hSimTracks

HTrackVariables* MuonTrackAnalyzer::hSimTracks

private

Definition at line 140 of file MuonTrackAnalyzer.h.

numberOfRecTracks

int MuonTrackAnalyzer::numberOfRecTracks

private

Definition at line 150 of file MuonTrackAnalyzer.h.

numberOfSimTracks

int MuonTrackAnalyzer::numberOfSimTracks

private

Definition at line 149 of file MuonTrackAnalyzer.h.

out

std::string MuonTrackAnalyzer::out

private

Definition at line 91 of file MuonTrackAnalyzer.h.

pset

edm::ParameterSet MuonTrackAnalyzer::pset

private

Definition at line 93 of file MuonTrackAnalyzer.h.

subsystemname_

std::string MuonTrackAnalyzer::subsystemname_

private

Definition at line 92 of file MuonTrackAnalyzer.h.

theCSCSimHitLabel

edm::InputTag MuonTrackAnalyzer::theCSCSimHitLabel

private

Definition at line 101 of file MuonTrackAnalyzer.h.

theCSCSimHitToken

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

private

Definition at line 108 of file MuonTrackAnalyzer.h.

theDTSimHitLabel

edm::InputTag MuonTrackAnalyzer::theDTSimHitLabel

private

Definition at line 102 of file MuonTrackAnalyzer.h.

theDTSimHitToken

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

private

Definition at line 109 of file MuonTrackAnalyzer.h.

theEtaRange

EtaRange MuonTrackAnalyzer::theEtaRange

private

Definition at line 96 of file MuonTrackAnalyzer.h.

theRPCSimHitLabel

edm::InputTag MuonTrackAnalyzer::theRPCSimHitLabel

private

Definition at line 103 of file MuonTrackAnalyzer.h.

theRPCSimHitToken

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

private

Definition at line 110 of file MuonTrackAnalyzer.h.

theSeedPropagatorName

std::string MuonTrackAnalyzer::theSeedPropagatorName

private

Definition at line 114 of file MuonTrackAnalyzer.h.

theSeedsLabel

edm::InputTag MuonTrackAnalyzer::theSeedsLabel

private

Definition at line 99 of file MuonTrackAnalyzer.h.

theSeedsToken

edm::EDGetTokenT<TrajectorySeedCollection> MuonTrackAnalyzer::theSeedsToken

private

Definition at line 106 of file MuonTrackAnalyzer.h.

theService

MuonServiceProxy* MuonTrackAnalyzer::theService

private

Definition at line 116 of file MuonTrackAnalyzer.h.

theSimTracksLabel

edm::InputTag MuonTrackAnalyzer::theSimTracksLabel

private

Definition at line 98 of file MuonTrackAnalyzer.h.

theSimTracksToken

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

private

Definition at line 105 of file MuonTrackAnalyzer.h.

theTracksLabel

edm::InputTag MuonTrackAnalyzer::theTracksLabel

private

Definition at line 100 of file MuonTrackAnalyzer.h.

theTracksToken

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

private

Definition at line 107 of file MuonTrackAnalyzer.h.

theUpdator

MuonUpdatorAtVertex* MuonTrackAnalyzer::theUpdator

private

Definition at line 117 of file MuonTrackAnalyzer.h.