#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 51 of file MuonTrackAnalyzer.h.

Member Enumeration Documentation

enum MuonTrackAnalyzer::EtaRange

Enumerator
all
barrel
endcap

Definition at line 53 of file MuonTrackAnalyzer.h.

53 { all, barrel, endcap };

MuonTrackAnalyzer::endcap

Definition: MuonTrackAnalyzer.h:53

MuonTrackAnalyzer::barrel

Definition: MuonTrackAnalyzer.h:53

MuonTrackAnalyzer::all

Definition: MuonTrackAnalyzer.h:53

Constructor & Destructor Documentation

MuonTrackAnalyzer::MuonTrackAnalyzer ( const edm::ParameterSet & pset )

Constructor.

Definition at line 41 of file MuonTrackAnalyzer.cc.

References dbe_, edm::ParameterSet::getParameter(), HLT_FULL_cff::InputTag, MuonServiceProxy_cff::MuonServiceProxy, MuonUpdatorAtVertex_cff::MuonUpdatorAtVertex, Utilities::operator, submitPVResolutionJobs::out, TrackValidation_cff::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 ( )

override

Destructor.

Definition at line 86 of file MuonTrackAnalyzer.cc.

                                       {
   if (theService)
     delete theService;
 }

Member Function Documentation

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

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 170 of file MuonTrackAnalyzer.cc.

References LogDebug.

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

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, edm::InputTag::instance(), edm::InputTag::label(), edm::InputTag::process(), 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.);
   }
 }

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

private

Definition at line 394 of file MuonTrackAnalyzer.cc.

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

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

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

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

private

Definition at line 293 of file MuonTrackAnalyzer.cc.

References reco::TransientTrack::chi2(), ChiSquaredProbability(), LogTrace, CoreSimTrack::momentum(), reco::TransientTrack::ndof(), reco::TransientTrack::normalizedChi2(), and reco::TransientTrack::recHitsSize().

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

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

private

Definition at line 309 of file MuonTrackAnalyzer.cc.

References HTrack::computeResolutionAndPull(), MuonPatternRecoDumper::dumpTSOS(), HTrack::Fill(), HTrack::FillDeltaR(), TrajectoryStateOnSurface::globalMomentum(), LogTrace, CoreSimTrack::momentum(), dt_dqm_sourceclient_common_cff::reco, 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);
 }

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

private

Definition at line 324 of file MuonTrackAnalyzer.cc.

References HTrack::computeResolutionAndPull(), MuonPatternRecoDumper::dumpFTS(), HTrack::Fill(), HTrack::FillDeltaR(), LogTrace, CoreSimTrack::momentum(), FreeTrajectoryState::momentum(), dt_dqm_sourceclient_common_cff::reco, 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);
 }

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, TrajectorySeed::startingState(), 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;
 }

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

private

Definition at line 339 of file MuonTrackAnalyzer.cc.

References funct::abs(), TrajectoryStateOnSurface::globalMomentum(), LogTrace, mps_fire::result, cscDigiValidation_cfi::simTrack, 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);
 }

bool MuonTrackAnalyzer::isInTheAcceptance ( double eta )

private

Definition at line 379 of file MuonTrackAnalyzer.cc.

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

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

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, and DetachedQuadStep_cff::seeds.

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

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, CoreSimTrack::momentum(), PV3DBase< T, PVType, FrameType >::perp(), cscDigiValidation_cfi::simTrack, mathSSE::sqrt(), submitPVValidationJobs::t, HLT_FULL_cff::track, and 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

DQMStore* MuonTrackAnalyzer::dbe_

private

Definition at line 89 of file MuonTrackAnalyzer.h.

std::string MuonTrackAnalyzer::dirName_

private

Definition at line 90 of file MuonTrackAnalyzer.h.

bool MuonTrackAnalyzer::doSeedsAnalysis

private

Definition at line 114 of file MuonTrackAnalyzer.h.

bool MuonTrackAnalyzer::doTracksAnalysis

private

Definition at line 113 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hChargeVsEta

private

Definition at line 129 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hChargeVsPt

private

Definition at line 130 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hChi2

private

Definition at line 121 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hChi2Norm

private

Definition at line 122 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hChi2NormVsEta

private

Definition at line 134 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hChi2Prob

private

Definition at line 125 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hChi2ProbVsEta

private

Definition at line 137 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hChi2VsEta

private

Definition at line 133 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hDeltaPt_In_Out_VsEta

private

Definition at line 139 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hDeltaPtVsEta

private

Definition at line 138 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hDof

private

Definition at line 124 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hDofVsEta

private

Definition at line 136 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hHitsPerTrack

private

Definition at line 123 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hHitsPerTrackVsEta

private

Definition at line 135 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hNumberOfTracks

private

Definition at line 127 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hNumberOfTracksVsEta

private

Definition at line 128 of file MuonTrackAnalyzer.h.

MonitorElement* MuonTrackAnalyzer::hPtRecVsPtGen

private

Definition at line 131 of file MuonTrackAnalyzer.h.

HTrack* MuonTrackAnalyzer::hRecoSeedInner

private

Definition at line 143 of file MuonTrackAnalyzer.h.

HTrack* MuonTrackAnalyzer::hRecoSeedPCA

private

Definition at line 144 of file MuonTrackAnalyzer.h.

HTrack* MuonTrackAnalyzer::hRecoTracksInner

private

Definition at line 146 of file MuonTrackAnalyzer.h.

HTrack* MuonTrackAnalyzer::hRecoTracksOuter

private

Definition at line 147 of file MuonTrackAnalyzer.h.

HTrack* MuonTrackAnalyzer::hRecoTracksPCA

private

Definition at line 145 of file MuonTrackAnalyzer.h.

HTrackVariables* MuonTrackAnalyzer::hSimTracks

private

Definition at line 141 of file MuonTrackAnalyzer.h.

int MuonTrackAnalyzer::numberOfRecTracks

private

Definition at line 151 of file MuonTrackAnalyzer.h.

int MuonTrackAnalyzer::numberOfSimTracks

private

Definition at line 150 of file MuonTrackAnalyzer.h.

std::string MuonTrackAnalyzer::out

private

Definition at line 92 of file MuonTrackAnalyzer.h.

edm::ParameterSet MuonTrackAnalyzer::pset

private

Definition at line 94 of file MuonTrackAnalyzer.h.

std::string MuonTrackAnalyzer::subsystemname_

private

Definition at line 93 of file MuonTrackAnalyzer.h.

edm::InputTag MuonTrackAnalyzer::theCSCSimHitLabel

private

Definition at line 102 of file MuonTrackAnalyzer.h.

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

private

Definition at line 109 of file MuonTrackAnalyzer.h.

edm::InputTag MuonTrackAnalyzer::theDTSimHitLabel

private

Definition at line 103 of file MuonTrackAnalyzer.h.

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

private

Definition at line 110 of file MuonTrackAnalyzer.h.

EtaRange MuonTrackAnalyzer::theEtaRange

private

Definition at line 97 of file MuonTrackAnalyzer.h.

edm::InputTag MuonTrackAnalyzer::theRPCSimHitLabel

private

Definition at line 104 of file MuonTrackAnalyzer.h.

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

private

Definition at line 111 of file MuonTrackAnalyzer.h.

std::string MuonTrackAnalyzer::theSeedPropagatorName

private

Definition at line 115 of file MuonTrackAnalyzer.h.

edm::InputTag MuonTrackAnalyzer::theSeedsLabel

private

Definition at line 100 of file MuonTrackAnalyzer.h.

edm::EDGetTokenT<TrajectorySeedCollection> MuonTrackAnalyzer::theSeedsToken

private

Definition at line 107 of file MuonTrackAnalyzer.h.

MuonServiceProxy* MuonTrackAnalyzer::theService

private

Definition at line 117 of file MuonTrackAnalyzer.h.

edm::InputTag MuonTrackAnalyzer::theSimTracksLabel

private

Definition at line 99 of file MuonTrackAnalyzer.h.

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

private

Definition at line 106 of file MuonTrackAnalyzer.h.

edm::InputTag MuonTrackAnalyzer::theTracksLabel

private

Definition at line 101 of file MuonTrackAnalyzer.h.

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

private

Definition at line 108 of file MuonTrackAnalyzer.h.

MuonUpdatorAtVertex* MuonTrackAnalyzer::theUpdator

private

Definition at line 118 of file MuonTrackAnalyzer.h.

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation