Using Electrons in Analysis

The following section will walk you through adding electrons to the analysis, applying selection cuts, and writing them to the output ntuple.

Add Electrons to your Job

We include electrons to our analysis by adding the following lines to your config.yaml file:

# Define analysis electron container, specify ID/Isolation working
# points, base pT/eta selection
Electrons:
  - containerName: 'AnaElectrons'
    WorkingPoint:
      - selectionName: 'loose'
        noEffSF: True
        identificationWP: 'LooseBLayerLH'
        isolationWP: 'Loose_VarRad'
    PtEtaSelection:
        minPt: 25000.0
        maxEta: 2.47

The Electrons line schedules electron calibration, scale factors and systematic variations. The containerName defines the container in which calibrated electrons that pass the selection are stored. The lines in the scope of WorkingPoint set requirements on the electron identification and isolation. The noEffSF line turns off the saving of the efficiency scale factors (corrections you should apply to the MC simulation to make it better match the data). Upon selection, the algorithm adds a decoration to each electron named baselineSelection_loose, where the loose selection name is prepended by baselineSelection_ automatically. It is saved as a char with a value of 0 or 1, indicating whether the electron passes the selection. The use of a char is to save disk space compared to using an int or bool.

Throughout ATLAS analysis software you will find decisions saved as chars with a value of 0 or 1.

Notice that there are different working points for “identification” and for “isolation”. Identification is about the properties of the shower in the calorimeter and the track; isolation is about how much energy is nearby in the calorimeter or in the tracker. Depending on your analysis, you might want looser identification requirements and tight isolation, or vice-versa.

The lines in the scope of PtEtaSelection apply some basic kinematic selection criteria for our electrons. We will not use electrons with p_T < 25 GeV or |η| > 2.47. This algorithm checks whether each electron passes the p_T and η requirements and decorates them with a flag called selectPtEta that we can access later to easily determine whether the electron passes the kinematic requirements.

To summarize what we’ve done here, including this block of text in the configuration file automatically retrieves the electron container from the xAOD and applies selection cuts based on the identification likelihood working point, isolation working point, p_T and η. (All this code is contained in the block sequences in Python that are invoked by this text in the config file, which, in turn, contain the algorithms and tools in C++ that perform the actual selections.)

Write the electron information to the ntuple

To write the electrons to the output ntuple, we must specify their output thinning and their output container. Let’s start with their thinning block. Add the following lines of text to the config.yaml file:

# Apply object thinning and specify the name for the thinned container.
Thinning:
  - containerName: 'AnaElectrons'
    outputName: 'OutElectrons'
    selectionName: 'loose'

This block maps the input container being processed ('AnaElectrons') to its output container ('OutElectrons').

Now, we want to specify the branches of the output ntuple that map to the electron container. For this, modify the Output block in the config.yaml file to include:

        'el_': 'OutElectrons'

nested under containers:. Here, we specify that branches with electron information are denoted by the prefix el_ and contain information from the OutElectrons container we defined in the Thinning block.

Go ahead and re-run. Congrats, we have electrons!

Examine the output electrons

Now that we have added electrons to our ntuple, take a look at them. Open submitDir/data-ANALYSIS/dataset.root and look for el_* branches in analysis. Draw some of the kinematic branches to see their distributions.

What are the units of momentum being used?

Some of the electron branches end with _NOSYS while others do not. This suffix is used for the nominal values of variables that can have systematic variations. When systematics are enabled, you will see versions of these branches with different suffixes.

Why does the el_select_loose branch change with systematic uncertainties?

When you are satisfied with the result, commit and push your code changes.