PAT Examples: Trigger and reconstruction performance of muons

Contents

Introduction

This tutorial will be concerned with the Performance of the Reconstruction of Muons in Z-->μμ Events. We will make use of the Physics Analysis Toolkit PAT but concentrate on performance and physics aspects. We will be concerned with the following topics:

  • What is the difference of the basic muon quantities when reconstructed from the inner/outer track detector alone or from both detectors?
  • What is the difference in the resolution of the Z boson mass peak when reconstructed from the inner/outer track detector alone or from both detectors?
  • What is the influence of a shift in the transverse momentum of the reconstructed muons on the Z boson mass?

Finally we will determine the expected turn-on curve of the HLT_Mu9 trigger bit as function of the transverse momentum of the offline reconstructed muon. We will make use of pre-processed PAT tuples. A short explanation of the the configuration files that have been used to produce them will be given below. All exercises of this tutorial are based on a simulated sample of Z+jets events produced with the madgraph event generator. You can find the corresponding files on DBS here. We make use of a total of roughly 30k events. You will be guided through the exercises step by step. Questions will help you to probe your understanding of each section.

How to get the code

First of all connect to lxplus and go to some working directory. You can choose any directory, provided that you have enough space. You need ~5 MB of free disc space for this exercise. We recommend you to use your ~/scratch0 space. In case you don't have this (or do not even know what it is) check your quota typing fs lq and follow this link. If you don't have enough space, you may instead use the temporary space (/tmp/your_user_name), but be aware that this is lost once you log out of lxplus (or within something like a day). We will expect in the following that you have such a ~/scratch0 directory.

ssh lxplus
[ ... enter password ... ]
cd scratch0/

Create a directory for this exercise (to avoid interference with code from the other exercises).

mkdir muonExercise
cd muonExercise

Create a local release area and enter it.

cmsrel CMSSW_5_3_14
cd CMSSW_5_3_14/src 

The first command creates all directories needed in a local release area. Setting up the environment is done invoking the following script:

cmsenv

A simplistic muon analysis

We will explore a few basic quantities of the muons that form the Z boson candidate first. For this we make use of a PAT tuple that has been pre-produced with the file producePatZToMuMu_cfg.py in the test directory of the PatExamples package. You need to check out and compile the package as given below:

addpkg PhysicsTools/PatExamples V00-05-16
scram b PhysicsTools/PatExamples

ALERT! Note: You might want to use more than one core to compile the package making use of the scram compiler flag -j followed by the number of cores you would like to make use of.

In the meantime you might want to have a look into the file for the PAT tuple production (producePatZToMuMu_cfg.py) in the test directory of the PatExamples package:

## Starting with a skeleton process which gets imported with the following line
from CMS.PhysicsTools.PatAlgos.patTemplate_cfg import *

## ---
## Use proper input
## ---
from CMS.PhysicsTools.PatExamples.samplesDESY_cff import *
process.source.fileNames = zjetsRECO


## ---
## Adjust inputs if necessary
## ---
from CMS.PhysicsTools.PatAlgos.tools.cmsswVersionTools import run36xOn35xInput
run36xOn35xInput(process)

## This might be needed when running on 383 rereco'ed data
process.load("RecoJets.Configuration.GenJetParticles_cff")
process.load("RecoJets.Configuration.RecoGenJets_cff")

process.p0 = cms.Path(
    process.genJetParticles *
    process.ak5GenJets
)

## ---
## Determine number of events to be processed
## ---
process.maxEvents.input = 100

## ---
## Adaptations to the event content
## ---
process.p = cms.Path(
    process.patDefaultSequence
)

## Switch embedding to false
process.patMuons.embedStandAloneMuon = False
process.patMuons.embedCombinedMuon = False
process.patMuons.embedTrack = False

## Keep tracks and track extras instead
process.out.outputCommands+= [
    "keep *_globalMuons_*_*",
    "keep *_generalTracks_*_*",
    "keep *_standAloneMuons_*_*"
    ]

ALERT! Note: We start from the default configuration for the production of PAT tuples as defined in the patTuple_template_cfg.py file located in the PatAlgos package. The input files are defined by the vector zjetsRECO. As this file has been produced with an older CMSSW release we need a few adaptations as given in the following lines. ( These are mostly about collections that have been renamed in more actual releases ). In addition to the default configuration we add all information about globalMuons, generalTracks and standaloneMuons, as we want to make use of it later. This concerns reco::Track collections and reco::TrackExtra collections. As we keep them in the event we do not to need to embed them into the PAT muons. If you want to learn more about the reasons and mechanisms of embedding information into PAT candidate collections have a look at Exercise 6 of the WorkBookPATTutorial. You should run this file on a few hundred events to see what it does.

[rwolf@tcx112]~/data/CMSSW_3_8_4/src% cmsRun PhysicsTools/PatExamples/test/producePatZToMuMu_cfg.py
*********************************************************************
NOTE TO USER: when running on 35X sample with 36X s/w versions you
              need to adapt for different event contents. The
              adaptations need to be made:

               - re-configuration of secondary vertex tag discrimi-
                 nator information.

*********************************************************************
28-Sep-2010 11:52:25 CEST  Initiating request to open file dcap://dcache-door-cms09.desy.de//pnfs/desy.de/cms/tier2/store/mc/Spring10/ZJets-madgraph/AODSIM/START3X_V26_S09-v1/0013/00EFC4EA-3847-DF11-A194-003048D4DF80.root
28-Sep-2010 11:52:28 CEST  Successfully opened file dcap://dcache-door-cms09.desy.de//pnfs/desy.de/cms/tier2/store/mc/Spring10/ZJets-madgraph/AODSIM/START3X_V26_S09-v1/0013/00EFC4EA-3847-DF11-A194-003048D4DF80.root
Begin processing the 1st record. Run 1, Event 559001, LumiSection 1 at 28-Sep-2010 11:52:38 CEST
Begin processing the 2nd record. Run 1, Event 559008, LumiSection 1 at 28-Sep-2010 11:52:50 CEST
Begin processing the 3rd record. Run 1, Event 559009, LumiSection 1 at 28-Sep-2010 11:52:51 CEST
Begin processing the 4th record. Run 1, Event 559010, LumiSection 1 at 28-Sep-2010 11:52:51 CEST
Begin processing the 5th record. Run 1, Event 559011, LumiSection 1 at 28-Sep-2010 11:52:51 CEST
Begin processing the 6th record. Run 1, Event 559012, LumiSection 1 at 28-Sep-2010 11:52:51 CEST
Begin processing the 7th record. Run 1, Event 559013, LumiSection 1 at 28-Sep-2010 11:52:51 CEST
Begin processing the 8th record. Run 1, Event 559014, LumiSection 1 at 28-Sep-2010 11:52:52 CEST
Begin processing the 9th record. Run 1, Event 559019, LumiSection 1 at 28-Sep-2010 11:52:52 CEST
Begin processing the 10th record. Run 1, Event 559020, LumiSection 1 at 28-Sep-2010 11:52:52 CEST
Begin processing the 11th record. Run 1, Event 559021, LumiSection 1 at 28-Sep-2010 11:52:52 CEST
Begin processing the 12th record. Run 1, Event 559026, LumiSection 1 at 28-Sep-2010 11:52:52 CEST
Begin processing the 13th record. Run 1, Event 559028, LumiSection 1 at 28-Sep-2010 11:52:52 CEST
Begin processing the 14th record. Run 1, Event 559029, LumiSection 1 at 28-Sep-2010 11:52:52 CEST
Begin processing the 15th record. Run 1, Event 559030, LumiSection 1 at 28-Sep-2010 11:52:53 CEST
...

Question Question a):
Inspect the output of the file with the edmDumpEventContent tool what are the collections that were saved to the PAT tuple? What collections will you actually make use of when analysing only the muons?

We will analyse these data making use of the PatZToMuMuAnalyzer module as explained below. You can start the analysis by typing the following line in the head of your working directory.

[rwolf@tcx112]~/data/CMSSW_3_8_4/src% cmsRun PhysicsTools/PatExamples/test/analyzePatZToMuMu_cfg.py
28-Sep-2010 11:54:27 CEST  Initiating request to open file dcap://dcache-door-cms09.desy.de//pnfs/desy.de/cms/tier2/store/user/rwolf/school/patTuple_zjets_tracks.root
28-Sep-2010 11:54:30 CEST  Successfully opened file dcap://dcache-door-cms09.desy.de//pnfs/desy.de/cms/tier2/store/user/rwolf/school/patTuple_zjets_tracks.root
Begin processing the 1st record. Run 1, Event 559001, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 2nd record. Run 1, Event 559008, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 3rd record. Run 1, Event 559009, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 4th record. Run 1, Event 559010, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 5th record. Run 1, Event 559011, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 6th record. Run 1, Event 559012, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 7th record. Run 1, Event 559013, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 8th record. Run 1, Event 559014, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 9th record. Run 1, Event 559019, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 10th record. Run 1, Event 559020, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 11th record. Run 1, Event 559021, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 12th record. Run 1, Event 559026, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 13th record. Run 1, Event 559028, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 14th record. Run 1, Event 559029, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 15th record. Run 1, Event 559030, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
Begin processing the 16th record. Run 1, Event 559031, LumiSection 1 at 28-Sep-2010 11:54:35 CEST
...

The structure of the configuration file analyzePatZToMuMu_cfg.py, as located in the test directory of the PatExamples package is given below:

import FWCore.ParameterSet.Config as cms

## Declare process
process = cms.Process("MuonAna")

## Declare input
from CMS.PhysicsTools.PatExamples.samplesDESY_cff import *

process.source = cms.Source("PoolSource",
  fileNames = zjetsTracks
)

process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32( -1 )
)

## Message logger configuration
process.MessageLogger = cms.Service("MessageLogger")

## Selection of good muons
from CMS.PhysicsTools.PatAlgos.selectionLayer1.muonSelector_cfi import *
process.goodMuons = selectedPatMuons.clone(
    src="cleanPatMuons",
    cut='pt>20. & abs(eta)<2.1 & (trackIso+caloIso)/pt<0.1',
)

## Monitor muons
process.load("CMS.PhysicsTools.PatExamples.PatZToMuMuAnalyzer_cfi")
process.analyzeZToMuMu.muons = 'goodMuons'

## Define output file
process.TFileService = cms.Service("TFileService",
  fileName = cms.string('analyzePatZToMuMu.root')
)

process.p = cms.Path(
    process.goodMuons *
    process.analyzeZToMuMu
)

ALERT! Note: We open the input file and apply some minimal set of requirements on the muons that we want to analyse: They should have a pt>20 GeV and be measurable in the central detector. In addition we require them to be isolated within the inner track detector and the calorimeters. Then we run the EDAnalyzer module to fill our histograms. You can find the complete definition of the EDAnalyzer module here. You can find more information about the structure of the module in the next section.

Find out more about the module structure

While the events are being processed you can have a closer look into the structure of the module itself. You can find it in the plugins directory of the PatExamples package. For simplicity reasons the class definition is given together with its implementation in the same PatZToMuMuAnalyzer.cc file:

class PatZToMuMuAnalyzer : public edm::EDAnalyzer {
  
 public:
  /// typedef's to simplify get functions
  typedef math::XYZVector Vector;
  typedef math::XYZTLorentzVector LorentzVector;

  /// default constructor
  explicit PatZToMuMuAnalyzer(const edm::ParameterSet& cfg);
  /// default destructor
  ~PatZToMuMuAnalyzer(){};
  
 private:
  /// everything that needs to be done during the event loop
  virtual void analyze(const edm::Event& event, const edm::EventSetup& setup);

  /// calculate the mass of the Z boson from the tracker momenta by hand
  double mass(const math::XYZVector& t1, const math::XYZVector& t2) const;
  /// check if histogram was booked
  bool booked(const std::string histName) const { return hists_.find(histName.c_str())!=hists_.end(); };
  /// fill histogram if it had been booked before
  void fill(const std::string histName, double value) const { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(value); };
  /// fill a predefined set of histograms from inner outer or global tracks for first and second mu candidate
  void fill(std::string hists, const reco::TrackRef& t1, const reco::TrackRef& t2) const;

  /// input for muons
  edm::InputTag muons_;
  /// shift in transverse momentum to determine a
  /// rough uncertainty on the Z mass estimation
  double shift_;
  /// management of 1d histograms
  std::map< std::string, TH1D* > hists_;
};

ALERT! Note: We abandoned the typical beginJob and endJob functions and added a few functions for histogram management. The histograms are stored in a std::map. The module takes two parameters:

  • muons_: to define the input collection,
  • shift_: to define a potential shift in the pt of the muons that form the Z boson candidate.

This shift should be understood as a relative shift, i.e. a parameter of shift_=1.05 will result in a pt, which is +5% larger than the original pt of the muon candidate. You can find the parameters read out in the constructor of the module and defined in the PatZToMuMuAnalyzer_cfi.py file in the python directory of the PatExamples package:

PatZToMuMuAnalyzer::PatZToMuMuAnalyzer(const edm::ParameterSet& cfg):
  muons_(cfg.getParameter< edm::InputTag >("muons")),
  shift_(cfg.getParameter< double >("shift"))
{
  edm::Service< TFileService > fileService;
  
  // mass plot around Z peak from global tracks
  hists_[ "globalMass"] = fileService->make< TH1D >( "globalMass" , "Mass_{Z} (global) (GeV)",   90,    30.,   120.);
  // eta from global tracks
  hists_[ "globalEta" ] = fileService->make< TH1D >( "globalEta"  , "#eta (global)"          ,   48,   -2.4,    2.4);
  // pt from global tracks
  hists_[ "globalPt"  ] = fileService->make< TH1D >( "globalPt"   , "p_{T} (global) (GeV)"   ,  100,     0.,   100.);
  // mass plot around Z peak from inner tracks
  hists_[ "innerMass" ] = fileService->make< TH1D >( "innerMass"  , "Mass_{Z} (inner) (GeV)" ,   90,    30.,   120.);
  // eta from inner tracks
  hists_[ "innerEta"  ] = fileService->make< TH1D >( "innerEta"   , "#eta (inner)"           ,   48,   -2.4,    2.4);
  // pt from inner tracks
  hists_[ "innerPt"   ] = fileService->make< TH1D >( "innerPt"    , "p_{T} (inner) (GeV)"    ,  100,     0.,   100.);
  // mass plot around Z peak from outer tracks
  hists_[ "outerMass" ] = fileService->make< TH1D >( "outerMass"  , "Mass_{Z} (outer) (GeV)" ,   90,    30.,   120.);
  // eta from outer tracks
  hists_[ "outerEta"  ] = fileService->make< TH1D >( "outerEta"   , "#eta (outer)"           ,   48,   -2.4,    2.4);
  // pt from outer tracks
  hists_[ "outerPt"   ] = fileService->make< TH1D >( "outerPt"    , "p_{T} (outer) (GeV)"    ,  100,     0.,   100.);
  // delta pt between global and outer track
  hists_[ "deltaPt"   ] = fileService->make< TH1D >( "deltaPt"    , "#Delta p_{T} (GeV)"     ,  100,   -10.,    10.);
  // delta eta between global and outer track
  hists_[ "deltaEta"  ] = fileService->make< TH1D >( "deltaEta"   , "#Delta #eta"            ,  100,   -0.2,    0.2);
  // delta phi between global and outer track
  hists_[ "deltaPhi"  ] = fileService->make< TH1D >( "deltaPhi"   , "#Delta #phi"            ,  100,   -0.2,    0.2);

ALERT! Note: In the following section the histograms are booked: we fill the invariant mass of the Z boson candidate and the pt and eta for each muon pair from the globalMuon track, the standaloneMuon track and from the generalTrack, which corresponds to the inner track detector only. In addition we fill the Δpt, Δeta, Δphi between the globalMuon track and the standaloneMuon track from the muon system only. Have a look to the analyze function of the module to learn more about the exact implementation. Feel free to add more interesting distributions. Once your cmsRun is finished open the analyzePatZToMuMu.root file with a root Browser and answer the following questions:

Question Question b):
What is the RMS of the difference Δpt, Δeta, Δphi between the globalMuon track and the standaloneMuon track? Is there a resulting bias?

Question Question c):
What is the RMS of the the Z boson mass peak as reconstructed from the inner/outer tracker alone and from the globalMuon track?

Question Exercise a):
Answer question b) and c) with the following additional requirements on the muons:

  • isTrackerMuon==1
  • isGlobalMuon==1
  • innerTrack.numberOfValidHits>=11
  • globalTrack.normalizedChi2<10.0
  • globalTrack.hitPattern.numberOfValidMuonHits>0
  • abs(dB)<0.02
  • (trackIso+caloIso)/pt<0.05
This is a typical selection for isolated muons in top events. Do you expect changes?

Question Exercise b):
Check the influence of a shift of +5% and -5% on the pt of the reconstructed tracks on the invariant mass of the Z boson candidate.

#CMS.TagAndProbe

Tag and probe method to determine the trigger efficiency

We will next determine the trigger turn-on curve for the HLT_Mu9 trigger bit as a function of the pt of the offline reconstructed muon. Therefore it has to be guaranteed that the event class of interest is written to tape unbiased. This can be achieved e.g. by an independent monitor trigger, which could be a jet trigger. In an ideal world this monitor trigger should fullfill the following requirements:

  • it should be unbiased.
  • if should not be prescaled.
  • it should have a sizable overlab with the selection trigger.
  • it should cover the full kinematic range of the measurment.

If the information is known which exact muon fired the trigger we can make use of the HLT_Mu9 trigger itself as monitor trigger exploiting a Tag and Probe method. In general tag and probe methods require the following inputs:

  • an event tag, which should guarantee that the event of inspection corresponds indeed to the event class of interest.
  • a probe object, which is the object on which a certain criterion is to be tested (i.e. an efficiency to be determined).

Within CMS the object that passed this criterion often is referred to as test object. In our example (Z-->μμ events) the probe is a muon with loose selection requirements; the tag consists of a well isolated muon, fulfilling strong selection requirements, which together with the probe forms a Z boson candidate within a certain window of the nominal mass. Thus we make sure that the reconstructed probe is indeed an isolated muon (originating from the Z boson). In our case we apply a strict selecting on both muons. For the tag we require in addition that it has fired the HLT_Mu9 trigger. We can than check whether the second muon also would have fired the trigger. This will result in an unbiased measurement if we allow the tag also to be chosen as probe if the second muon has fired the trigger as well. We made use of PAT to apply the match between the offline reconstructed muon and the trigger muon that were produced and used in the HLT_Mu9 trigger path. To learn how to do this have a look to Exercise 10 of the WorkBookPATTutorial. We start the analysis from the analyzerPatTriggerTagAndProbe_cfg.py configuration file, which can be found in the test directory of the PatExamples package, where we basically just run the EDAnalyzer module as defined below:

process.tagAndProbeAnalysis = cms.EDAnalyzer( "PatTriggerTagAndProbe",
    triggerEvent = cms.InputTag( "patTriggerEvent" ),
    muons        = cms.InputTag( "cleanPatMuons" ),
    muonMatch    = cms.string( 'muonTriggerMatchHLTMuons' )
)

ALERT! Note: The common entry point to all trigger information is the patTriggerEvent. The cleanPatMuons collection of offline reconstructed muons and the name of the match between the trigger muons and the offline reconstructed muons are additional input parameters. We have created this match beforehand during the PAT tuple production. Have a look to the procudePatTrigger_cfg.py file in the test directory of the PatExamples package to learn more about it. You can find the module definition in the plugins directory of the PatExamples package:

void PatTriggerTagAndProbe::analyze( const edm::Event & iEvent, const edm::EventSetup & iSetup )
{
  // trigger event
  edm::Handle< pat::TriggerEvent > triggerEvent;
  iEvent.getByLabel( triggerEvent_, triggerEvent );
  // pat candidate collection
  edm::Handle< pat::MuonCollection > muons;
  iEvent.getByLabel( muons_, muons );

  // pat trigger helper to recieve for trigger
  // matching information
  const pat::helper::TriggerMatchHelper matchHelper;

  // ask for trigger accept of HLT_Mu9; otherwise we don't even start
  if(!(triggerEvent->path("HLT_Mu9")->wasRun() && triggerEvent->path("HLT_Mu9")->wasAccept())){
    return;
  }

  // loop over muon references for the tag muon
  for( size_t idxTag=0; idxTag<muons->size(); ++idxTag){
    const pat::TriggerObjectRef trigRefTag( matchHelper.triggerMatchObject( muons, idxTag, muonMatch_, iEvent, *triggerEvent ) );
    if( trigRefTag.isAvailable() ){
      // loop over muon references for the probe/test muon
      for( size_t idxProbe=0; idxProbe<muons->size() && idxProbe!=idxTag; ++idxProbe){
	histos1D_[ "mass" ]->Fill( (muons->at(idxTag).p4()+muons->at(idxProbe).p4()).mass() );
	if(fabs((muons->at(idxTag).p4()+muons->at(idxProbe).p4()).mass()-90)<5){
	  const pat::TriggerObjectRef trigRefProbe( matchHelper.triggerMatchObject( muons, idxProbe, muonMatch_, iEvent, *triggerEvent ) );
	  histos1D_[ "probePt"  ]->Fill( muons->at(idxProbe).pt () );
	  histos1D_[ "probeEta" ]->Fill( muons->at(idxProbe).eta() );
	  if( trigRefProbe.isAvailable() ){
	    histos1D_[ "testPt" ]->Fill( muons->at(idxProbe).pt () );
	    histos1D_[ "testEta"]->Fill( muons->at(idxProbe).eta() );
	  }
	}
      }
    }
  }
}

ALERT! Note: In the analyze function we read in the patTriggerEvent and the cleanPatMuons collection of offline reconstructed muons. To find the corresponding match the matchHelper function needs to be defined, which takes the index of the offline reconstructed muons, the patTriggerEvent and the name of the muonMatch (as a std::string) as input and returns a reference to the matched trigger object. This reference can be empty if no match to the offline reconstructed muon was found. We require a match for the tag and fill two sets of histograms for the probe (corresponding to all muons), that form the reference and the test (corresponding to the muons that have a matched trigger muon associated). As we loop the same collection twice we allow also the tag to be used as a probe so we are unbiased by the trigger requirement. At the end we divide the test histograms by the probe histograms and calculate a set of binomial errors per bin. For more details have a look into the implementation of the module. Once your cmsRun is finished open the analyzePatTriggerTagAndProbe.root file with a root Browser and answer the following questions:

You can start the analysis by typing the following line in the head of your working directory:

[rwolf@tcx112]~/data/CMSSW_3_8_4/src% cmsRun PhysicsTools/PatExamples/test/analyzePatTriggerTagAndProbe_cfg.py
28-Sep-2010 16:47:40 CEST  Initiating request to open file dcap://dcache-door-cms09.desy.de//pnfs/desy.de/cms/tier2/store/user/rwolf/school/patTuple_zjets_trigger.root
28-Sep-2010 16:47:44 CEST  Successfully opened file dcap://dcache-door-cms09.desy.de//pnfs/desy.de/cms/tier2/store/user/rwolf/school/patTuple_zjets_trigger.root
Begin processing the 1st record. Run 1, Event 559001, LumiSection 1 at 28-Sep-2010 16:47:48 CEST
Begin processing the 2nd record. Run 1, Event 559008, LumiSection 1 at 28-Sep-2010 16:47:51 CEST
Begin processing the 3rd record. Run 1, Event 559009, LumiSection 1 at 28-Sep-2010 16:47:51 CEST
Begin processing the 4th record. Run 1, Event 559010, LumiSection 1 at 28-Sep-2010 16:47:51 CEST
Begin processing the 5th record. Run 1, Event 559011, LumiSection 1 at 28-Sep-2010 16:47:51 CEST
Begin processing the 6th record. Run 1, Event 559012, LumiSection 1 at 28-Sep-2010 16:47:51 CEST
Begin processing the 7th record. Run 1, Event 559013, LumiSection 1 at 28-Sep-2010 16:47:51 CEST
Begin processing the 8th record. Run 1, Event 559014, LumiSection 1 at 28-Sep-2010 16:47:51 CEST
...

Question Question d):
What is the efficiency of the HLT_Mu9 trigger for isolated muons with a pt larger than 30!GeV?

Question Question e):
At what pt does the efficiency curve exceed 60%, 80%?

Review status

Reviewer/Editor and Date (copy from screen) Comments
RogerWolf - 28 Sept 2010 first version for German Physics School

Responsible: RogerWolf

Topic attachments
I Attachment History Action Size Date Who Comment
Cascading Style Sheet filecss tutorial.css r1 manage 0.2 K 2010-09-27 - 22:15 RogerWolf  
Edit | Attach | Watch | Print version | History: r11 < r10 < r9 < r8 < r7 | Backlinks | Raw View | WYSIWYG | More topic actions
Topic revision: r11 - 2011-05-15 - SudhirMalik
 
    • Cern Search Icon Cern Search
    • TWiki Search Icon TWiki Search
    • Google Search Icon Google Search

    CMSPublic All webs login

This site is powered by the TWiki collaboration platform Powered by PerlCopyright & 2008-2019 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding TWiki? Send feedback