TrkAnaTutorial

Session Prerequisites

This tutorial is aimed at anyone starting ntuple analysis.

Before starting the Basic Exercises of this tutorial you should:

know about the physics of Mu2e;
have the appropriate docker container set up; and,
know how to run the Mu2e Offline software and ROOT.

In addition, for the Advanced Exercises, a deeper knowledge of art modules will be important.

Session Introduction

One of the final outputs of the Mu2e reconstruction are fits to the tracks in the tracker. These are stored as KalSeeds in KalSeedCollections. For each fit hypothesis, we have a different KalSeedCollection (e.g. downstream electrons, downstream muons, upstream positrons).

In order to do analyses with these tracks, we have an art module that creates a ROOT TTree of these KalSeeds called TrkAna. Each entry in the tree corresponds to a single track.

In this tutorial you will:

create TrkAna trees using the Mu2e Offline software and MDC2018 datasets; and,
analyze them using the ROOT command line and ROOT macros.

Basic Exercises

Setup

These exercises are designed to be run on v7_4_1 from $TUTORIAL_BASE/TrkAna

In the docker:

> source /setupmu2e-art.sh
> source /Offline/v7_4_1/SLF6/prof/Offline/setup.sh
> [source script that gives $TUTORIAL_BASE]
> cd $TUTORIAL_BASE/TrkAna

We also want to create some filelists for the exercises:

> mkdir filelists
>ls $TUTORIAL_BASE/data/mcs.mu2e.CeEndpoint-mix-cat.*.art > filelists/mcs.mu2e.CeEndpoint-mix-cat.MDC2018h.1-file.lst
>ls $TUTORIAL_BASE/data/mcs.mu2e.CRY-cosmic-general-mix-cat.*.art > filelists/mcs.mu2e.CRY-cosmic-general-mix-cat.MDC2018h.1-file.lst
>ls $TUTORIAL_BASE/data/mcs.mu2e.flatmugamma-mix-cat.*.art > filelists/mcs.mu2e.flatmugamma-mix-cat.MDC2018h.1-file.lst

If you are working on mu2egpvm, then the setup instructions will be different. These will be added to this tutorial at a later date.

Exercise 1: Creating the simplest TrkAna tree

In this exercise, we will create the simplest TrkAna tree and investigate it with the ROOT command line.

First, run mu2e on a single CeEndpoint-mix reco art file:
Now let's have a look at the TrkAna tree with the ROOT command line

evtinfo: event level information (e.g. event ID of the art::Event this track is from)
hcnt: hit count of different types of hit (e.g. number that pass certain selections)
tcnt: track count of different track types
trk: global fit information for the track (e.g. fit status, ranges of validity, number of hits)
trk(ent/mid/xit): local fit information for the track at the enttrance of the tracker, the middle of the tracker and exit of the tracker (e.g. fit momentum, pitch angle)
trktch: calorimeter hit information for the calorimeter function associated to the track (tch = TrkCaloHit)
crvinfo: information of associated hits in the CRV

Note that the "trk" parts of the branch names are configurable -- you will see this is a minute

Now we can plot some simple things:
1. the track momentum at the tracker entrance
2. the calorimeter cluster energy
3. With this last command you will see some entries at -1000. This means that there is no associated calorimeter cluster for this track. To exclude these we want to want to add a cut on the trktch.active flag (0 = there is no TrkCaloHit, 1 = there is TrkCaloHit):
Let's take a quick look at the fcl file to see how the TrackAnalysisReco module has been configured. Open it up in your favourite text editor and look at these important lines:

import an example TrkAna module configuration (you can find it in $MU2E_BASE_RELEASE/TrkDiag/fcl/prolog.fcl);
define the input KalSeedCollection that we want the TrkAna tree to read from (KFFDeM = KalFinalFit DownstreameMinus);
configure the name of the output branches;
set TrkAna to use the lowest diagnostic level (1 = simple list of tracks, 2 = hit level diagnostics); and,
make sure we are not touching the MC truth

That's the end of this exercise -- you can now create a simple TrkAna tree! Try the following optional exercise to explore further:

(Optional): Create a second instance of the TrackAnalysisReco module and configure it to look at positively charged tracks. Run on muplusgamma-mix (filelist/mcs.mu2e.flatmugamma-mix-cat.MDC2018h.1-file.lst) and count how many tracks of each type are found

Exercise 2: Calculating the Ce efficiency

Now that we can create a TrkAna tree, let's calculate how efficient our reconstruction is for conversion electrons with some signal cuts. There's a lot of concepts introduced in this exercise, so don't worry if it all doesn't make sense at first. I'll start with some quick notes on event counting, event weighting, and reco quality.

Event Counting

In the simulation, we generate a certain number of events. However, in order to save space, we only write out events that will produce a reconstructed tracks. We have various ways of filtering events but the result is the same -- the number of events in the output art files do not correspond to the number of events that were generated. We need to know the total number of generated events in order to calculate an absolute efficiency. We keep track of the number of events that were generated by creating a GenEventCount object for each SubRun. Then in our TrkAna job, we run the genCountLogger module to read the actual number of generated events.

Event Weighting

In each "mixed" event, we add a single "primary" particle onto a set of "background frames", which represent the background hits from other processes. We want to simulate the variable intensity of the proton beam at the production target and so we scale the number of background hits when we create the mixed event. However, we still only add a single primary particle and so we record the scale factor used in a ProtonBunchIntensity object for use later. In our TrkAna job, we will add a new module to the trigger path (PBIWeight), which translates the scale factor used for the proton bunch intensity into an EventWeight object. The TrackAnalysisReco module will write out these proton beam scale factors to a new branch (evtwt.PBIWeight). Event weighting is explored a little bit more in one of the optional exercises.

Reco Quality

We use various algorithms to check the "quality" of a track in some dimension. Currently there are two we consider:

the track quality (i.e. how will-reconstructed a track is); and
the particle ID (PID) quality (i.e. how closely a track resembles an electron rather than a muon).

In our TrkAna job, we will add two artificial neural network (ANN) based algorithms to determine these reco qualities (TrkQual and TrkCaloHitPID). In this exercise, we only care that the output of both of these modules is a RecoQualCollection with one RecoQual object per KalSeed. A RecoQual is essentially a float and, in these two algorithms, is between 0 (poorly-reconstructed, XXX PID) and 1 (well-reconstructed, YYY PID). TrkQual is explored in more detail in Advanced Exercise 3.

The Exercise

Now onto the exercise:

Create a TrkAna tree with CeEndpoint-mix tracks and include the genCountLogger, PBIWeight, TrkQual and TrkCaloHitPID modules

PBIWeight

Also in TrkAnaEx02.fcl, you will see that we have changed the input parameter to just "KFF"and added the suffix parameter:

DeM

DeP

If you open up the ROOT file and print the tree structure, you will notice the following new branches:

evtwt: stores the values of all EventWeight objects in the art event
trkqual: stores the values of all relevant RecoQual objects in the art event

Defining a suffix in the TrkAna configuration allows us to store only the relevant RecoQual values.

(Optional): Try running without a suffix parameter and set input back to "KFFDeM". What do you see in the output trkqual branch
Run this example ROOT macro that plots the track momentum onto a histogram with 0.5 MeV wide bins
Change the bin width to 0.05 MeV
Add the following signal cuts to the Draw function

the fit is successful (trk.status > 0)
the track is in the time window of 700 ns -- 1695 ns (trk.t0)
the tan-dip of the track is consistent with coming from the target: 0.577350 -- 1.000 (trkent.td)
the impact parameter of the track is consistent with coming from the target: -80 mm -- 105 mm (trkent.d0)
the maximum radius of the track is OK: 450 mm -- 680 mm (trkent.d0 + 2./trkent.om)
the track is of good quality (trkqual.TrkQualDeM > 0.8)

Because we simulated each event with a different proton bunch intensity, each track should be weighted by the PBIWeight. To do this you will want to modify the cut command to add the event weighting:
Now we can count the number of tracks that pass all these cuts
We can also integrate in the momentum signal region with the same function. Be careful TH1F::Integral takes bin numbers as its arguments and not x-values. Some hints:

you can find a bin for a given x-value with hist->GetXaxis()->FindBin(x-value)
make sure you aren't off by one bin by checking the bin low edges and bin high edges with TAxis::GetBinLowEdge() and TAxis::GetBinUpEdge().

To calculate the efficiency you need to know the number of events generated for this simulation. This is stored in the output of the genCountLogger module
Now you can calculate the absolute Ce efficiency. What's the answer?

Now that you can calculate the Ce efficiency, try some of the following exercises:

(Optional): Make the plot prettier by:

adding appropriate axis labels
writing the Ce efficiency on the plot with a TLatex
adding dashed lines to show the momentum window with TLines (extra bonus: have the lines move when the momentum window values change)

(Optional): Add a second momentum plot but with a higher track quality cut and include a TLegend.
(Optional): Add the following module to your producer block and append it to your trigger path

evtwt

without having to reconfigure TrkAna!

Exercise 3: Adding MC truth

In this exercise, we will add MC truth information to the TrkAna tree and see how close our reconstruction matches the truth.

Create a TrkAna tree with CeEndpoint-mix tracks and include the MC truth information:

fillMCInfo

candidate.fillMC

You can open up the file and Print the tree structure. For this exercise, we will focus on the trkmcent, which contains the MC information for the step that crossed the entrance into the tracker. The other trkmc* branches will be the focus of Exercise 4.
Run this example ROOT macro that plots the intrinsic tracker momentum for tracks that pass our signal cuts except for the trkqual and momentum window cuts
Add the following line to the start of the macro:
Using what you learned in Exercise 2, count the number of events above +3 MeV, including the events in the overflow bin
Add the trkqual cut and play with it. How does the number of events above +3 MeV change?

(Optional): Do the same comparison at the middle or exit of the tracker
(Optional): Perform a fit to a double-sided crystal ball function. This function is a Gaussian with polynomial tails. The function can be found here: scripts/dscb.h. You will need to create your own TF1 (hint) and use the TH1::Fit() function (hint). What is the core resolution?

Exercise 4: Following genealogy

With TrkAna, we also have access to important steps in the genealogy of the track (i.e. which particles produced the track). Before looking at the branches themselves, we need to discuss a little about the simulation.

For each event in the simulation we instantiate a GenParticle, which represents the particle we want to start the simulation with. For some of our samples, we create more than one of these per event (e.g. for cosmic rays, we take all the particles created in the shower at a certain altitude). We then pass these GenParticles to the physics simulation and create a SimParticle for each one. We then let Geant4 simulate these SimParticles and create more SimParticles until we end up with StepPointMCs in the detectors. For the tracker, there will be many different StepPointMCs from different SimParticles in every straw. We assign a SimParticle to be responsible for each straw hit if it had the most StepPointMCs in that hit.

Now here is a description of the branches we have in TrkAna:

trkmc: contains information about the SimParticle that produced the most hits on the track
trkmcgen: contains information about the actual GenParticle in our simulation that ultimately produced the track (e.g. for cosmic rays, this will be the particle in the shower that ultimately produced the track)
trkmcpri: contains information about the primary particle that produced the trkmcgen particle (e.g. for cosmic rays, this will correspond to the cosmic ray that produced the shower (i.e. the proton))

For most of our samples, these are all the same particle. In order to explore the differences, we will run on a sample of cosmic rays made by the CRY generator.

Create a TrkAna tree with CRY-cosmic-general-mix tracks and include the MC truth information:
Open the ROOT file and look at the PDG ID codes of the MC particles (defined here but some important ones are 11 = electron, -11 = positron, 13 = muon, -13 = positive muon, 2212 = proton).

GenParticles

However just because we have two particles of the same type at the different stages, does not mean that they are the same particle. We need look at the trkmc.prel, which encodes the relationship between the track particle and the GenParticle:
Anything else to do here?

That's it for this exercise. As you can tell, this isn't an exhaustive genealogy tree so if you need to look at something more complex, then you can run in the full Offline framework where we (currently) store every step in the genealogy for saved tracks. However, you can try this optional exercise for another example:

(Optional): Run on the flatmugamma-mix (internalRMC would be better...) file list and look at the genealogy of those tracks

Exercise 5: Adding supplemental tracks

From the last exercise, we can see that we get muon tracks. But we were only looking at the result of the electron-hypothesis fit. We can have TrkAna write out the results of "supplement" fits (e.g. downstream muon track)

Create a TrkAna tree with CRY-cosmic-general-mix tracks and include the result of downstream mu-minus fits:
Open up the fcl file and you will see that we have created a couple of blocks to handle branch definitions:

de

KalSeed

Open up the ROOT file and look in the tree. You will see that we now have both de* branches and dm* branches
Plot resolution for DeM like you did in Exercise 3. You will see that it doesn't look great...
Add cuts on the true MC particle and compare the resolutions (demc==11, demc==-11, demc==13, and demc==-13)
Now let's look at the resolution of the muon-hypothesis fits

re-run TrkAnaEx05.fcl but set the DmuM branch to be filled with MC information
re-run your ROOT macro but look at the DmuM branch rather than DeM branch

You will see that the true mu^{-} histogram is now centered at 0

Obviously in the real experiment, we won't know what the true particle is and so we need to use reconstructed quantities to get a handle on the truth. In TrkAna we have TrkQual and TrkPID so play with cuts on one or both of dequal.TrkQualDeM and dequal.TrkPIDDeM to remove as much of the "wrong" truth while keeping as much of the "correct" truth as possible

Here are some optional exercises:

(Optional): add upstream e-minus fits (UeM) as a supplement and plot the number of tracks of each type (branch <code?tcnt
(Optional): Swap the candidate (DeM) with one of the supplements (e.g. UeM) and re-run. You will notice that you will have more candidate (UeM) tracks now than when it was a supplement. This is because we were only writing out a supplement track if there was a candidate track in the same event, so we would have missed events that only have the supplement.

Exercise 6: TrkAnaReco

In this exercise, we will run the standard TrkAnaReco.fcl that is available in the repository. This

Run TrkAnaReco.fcl
If you open up the resulting nts.owner.trkana-reco.version.sequencer.root file and look at its contents, you will see that we run two instances of TrkAna: one for negative tracks (TrkAnaNeg) and one for positive tracks (TrkAnaPos), as well as the genCountLogger
If you cd into one of the TrkAna folders and print the tree structure, it will look very similar to the trees you've made in the previous exercises
There are two additions though:

detrkqual: this contains all the input variables that can be used for training the TrkQual MVA
detrkpid: this contains all the input variables that can be used for training the TrkCaloHitPID MVA

Both of these branches are turned on by setting candidate.trkqual and candidate.trkpid parameters to module labels and by setting fillTrkQual and fillTrkPID to true.

There's not much to this exercise, but you can try to run some of the macros that you've written in the previous exercises on the output file produced here.

Advanced Exercises

Setup

These exercises are designed to be run on a Satellite release of v7_4_1 from $TUTORIAL_BASE/TrkAna. The Satellite release is important for exercises 4, 5 and 6.

In the docker:

> source /setupmu2e-art.sh
> [source script that gives $TUTORIAL_BASE]
> cd $TUTORIAL_BASE/TrkAna
> /Offline/v7_4_1/SLF6/prof/Offline/bin/createSatelliteRelease --directory .
> source setup.sh

We also want to create some filelists for the exercises:

> mkdir filelists
>ls $TUTORIAL_BASE/data/mcs.mu2e.CeEndpoint-mix-cat.*.art > filelists/mcs.mu2e.CeEndpoint-mix-cat.MDC2018h.1-file.lst

If you are working on mu2egpvm, then the setup instructions will be different. These will be added to this tutorial at a later date.

Exercise 1: Looking at the hits in the track

In this exercise, we will get TrkAna to give us more information about each track by writing out the information for each hit.

Run the example fcl

#include

Look at the tree and you will see a bunch more branches:

detsh: information about the straw hits that went into the fit (tsh = TrkStrawHit)
detsm: information about each straw the fit passes through (tsm = TrkStrawMaterial)
detshmc: truth information about the straw hits that went into the fit (tsh = TrkStrawHit)

Let's create a very rudimentary event display?

Exercise 2: Analyzing a TrkAna tree with a compiled macro

In this exercise, we will create a compiled ROOT macro that loops through each event and performs a more complex analysis. Simple TTree::Draw commands with cuts are great for quickly prototyping analyses but can cause issues in the longterm.

In the TrkAna tree, each branch is essentially a struct. We call them info structs and they can be found in $MU2E_BASE_RELEASE/TrkDiag/inc/*Info.hh. If you look in those files, you will see each struct and you will recognise the various leaf names. These structs are stored in a shared library so we can use them in compiled ROOT macros.

A TrkAna tree containing the full CeEndpoint-mix dataset can be found in $TUTORIAL_BASE/data/trkana-cem.root.

To motivate a little more why this is better than a complicated cut command, try to run a cut command with a typo in the leafname
Run the example script that will print some information about the first few tracks but first we need to update the ROOT_INCLUDE_PATH:
Here are the important lines:

#include

TrkInfo

TrkFitInfo

Add the demid branch by copying what is done for the deent branch
Add event weight info branch and print the PBI weight. You will need to include the file TrkDiag/inc/EventWeightInfo.hh and know that, in the current TrkAna tree, the PBI weight is stored in evt._weights[0]. This is a weakness in TrkAna at the moment (you could re-run with different weight modules and _weights[0] will be different). However it allows us to be more flexible in the number and provenance of EventWeight objects
Add arguments to the function for the filename and the treename. This allows you to run the same macro on two different files without having to recompile each time. Try running on trkana-cry.root
Create a "cutflow" plot of the cuts given in Basic Exercise 2 (i.e. for each track, if it passes the first cut add an entry to the first bin. If it then passes the second cut, add an entry to the second bin etc.)

That's it for writing a compiled TrkAna analysis macro. While writing this exercise, I noticed that ROOT also provides a TTreeReader class and a RDataFrame class, which seem to be more modern. TrkAna trees have not been tested with these. However, they may be supported in future.

Here are some optional exercises

(Optional): Do some complicated analysis?

Exercise 3: Retraining TrkQual

In this exercise, we will investigate This can just run TrkAnaReco.fcl but want to highlight that the TrkQualInfo is written out with the candidate.trkqual

Copy the training script (This is a standard TMVA script with our modifications)

Use[] lines are the TMVA options that are available
TCut lines are our cuts on what we decide are signal (well-reconstructed tracks) and background (poorly reconstructed tracks)
SetBackgroundWeight lines mean that we can weight the background events differently (i.e. to give the worst reconstructed tricks to have the most importance)
AddVariable lines define the input variables that we use

We will create a new set of weights by removing the max radius input variable so comment it out in the TrainTrkQual.C script
Now we'll retrain on a CRY sample
The TrkQual.root file contains important histograms that you can look at with the TMVA GUI:
In the TrkQual folder, we have the weights XML file that we can now use when running T
Create a new fcl file with the following contents:

TrackQuality

Now run your fcl on the flateminus-mix file
If you look at the TrkAna tree structure you will see that the result of your new training has been added to the dequal tree:
You can Scan or Draw these values to see how they compare
Plot the momentum resolutions (like in Basic Exercise 3) for cuts on each trkqual variable.

In this exercise, you retrained TrkQual on a different dataset and with a reduced set of input variables. This has been easy to do because of some underlying code in TrackQuality and MVATool that allows us to mask out missing input variables as defined in the weights XML file. Adding a variable to TrkQual is a little tricker, one would have to:

add it to the TrkQual object;
fill it in the TrackQuality module; and,
add it to the TrainTrkQual.C training script,

which would require a recompilation of Offline.

Exercise 4: Adding your own weight module

In this module we will create a new event weight module that will create an EventWeight object that will automatically be read into the TrkAna tree. It might be best if you've already covered the art module writing tutorial.

This module will be based around the templated WeightModule that can be found in TrkDiag/inc/WeightModule.hh. We will create an _module.cc, which will create the module itself and a Phys.hh file which will define the event weight calculation.In our example, we will just define a weight as twice the primary particle's x-momentum.

First create a file in inc/ called DoubleWeightPhys.hh and fill it with the following:

Phys

double weight(const art::Event& event)

DoubleWeightPhys(const fhicl::ParameterSet& pset)

Then create a file in src/ called DoubleWeight_module.cc with the following contents:

DoubleWeightPhys

Now create a fcl with the following content:

EventWeight

Run it and you will see that the DoubleWeight leaf have been added to the evtwt branch of TrkAna:
You can Scan evtwt.DoubleWeight and demcpri.momx to see that this worked

This way of writing an EventWeight module still hasn't made it's way throughout all of Offline. However, as long as your module creates an EventWeight object, it will automatically be written into the TrkAna tree.

Exercise 5: Adding your own custom branch to TrkAna

In this exercise, we will add a custom branch of a different data product to TrkAna using a new info struct.

In addition, copy the current TrackAnalysisReco_module.cc into this area since we will need to modify it:

cp $MU2E_BASE_RELEASE/TrkDiag/src/TrackAnalysisReco_module.cc AdvEx05/src/TrackAnalysisRecoCustom_module.cc</code>

Don't forget to do a find and replace of "TrackAnalysisReco" to "TrackAnalysisRecoCustom".

Also, we will need our own InfoStructHelper:

> cp $MU2E_BASE_RELEASE/TrkDiag/inc/InfoStructHelper.hh solutions/AdvEx05/inc/InfoStructHelperCustom.hh
> cp $MU2E_BASE_RELEASE/TrkDiag/src/InfoStructHelper.cc solutions/AdvEx05/src/InfoStructHelperCustom.cc

and do a find-and-replace of "InfoStructHelper" to "InfoStructHelperCustom" in all your files.

Compile and make sure things run as expected (there is an example fcl file in AdvEx05/fcl/TrkAnaAdvEx05.fcl)

For this example, we will add the EventWindowMarker object, which is the start of the event relative to the proton beam arrival.</nowiki>
If you look in DataProducts/inc/EventWindowMarker.hh, you will see that it just contains a time offset
Let's create an info struct that will be used as the basis of the branch:

leafnames()

reset()

Now lets add a function to InfoStructHelperCustom to fill this in. I will leave this to you to add but it should have a function signature like so:
Now, in TrackAnalysisRecoCustom we need to add the following (in order as we go down through the source code)

a fcl parameter to take the art::InputTag of the module that creates the EventWindowMarker object
a private member variable for the EWMInfo struct
create the branch (in beginJob)
fill the branch (in fillEventInfo
clear the branch (in resetBranches)

Recompile with scons -j4 and fix any errors
Now edit your fcl to use the new EventWindowMarkerTag fcl parameter (the value you should use is "SelectRecoMC") and re-run
If you look in the output ROOT file, there will be a TrkAnaCustom folder, in which is your modified TrkAna tree:
You can Scan or Draw your new branch to see what it looks like

You've just added a new branch to the TrkAna tree. This might be useful in the future, if you have a custom data object that you want outputted alongside all the standard track information that TrkAna provides.

Here is an optional exercise to try:

(Optional): make the new branch optional with a fcl parameter and to not be used by default

Exercise 6: Creating your own "TrkAna" tree using InfoStructs

For this exercise, let's say you want a fundamentally different structure to what the TrkAna tree offers (e.g. instead of one row per track, you want one row per calorimeter cluster) but you still want a branch stored with KalSeed information. Do you need to

There's a skeleton module in AdvEx06/src that creates a tree with one calorimeter cluster per row as well as the art event information. After setting up the satellite release, compile and run the example:
Now let's add a branch for the information from the KalSeed:

add a fhicl parameter for the input KalSeedCollection
add private member variables of type TrkInfo and InfoStructHelper
create the branch (in beginJob())
call the updateSubRun function of InfoStructHelper in beginSubRun()
grab the KalSeedCollection from the event (in analyze)
in this step of the exercise, we will just write out the first KalSeed in the collection:
reset the TrkInfo struct (in resetBranches())

Recompile and re-run with the added fhicl parameter (it's value should be "KFFDeM")
Look in the output file and at the new tree and you will see that we have all the information about the global track fit with only a few lines of code
To make this a little more useful, let's only write out the TrkInfo, if the calorimeter cluster was used in the Kalman fit. This means we can see the calorimeter clusters that weren't used. Make the following changes:

loop over all the KalSeeds
get the calo cluster used in the track fit (KalSeed::caloCluster() returns a Ptr) if it has one (KalSeed::hasCaloCluster() returns a bool
only fill TrkInfo if the energy deposit is the same as the original cluster (NB there should be a better way of identifying the same cluster)
make sure to clear the TrkInfo struct before filling it

Re-compile, re-run and re-Scan the tree and you will see that now only some clusters have TrkInfo associated with it
Plot the energy spectrum of all energy clusters and those that have an associated track

Now you can create a TTree with your own structure and fill it easily with information that we have in TrkAna.

Reference Materials

Use this place to add links to reference materials.
TrkAna wiki page

A Useful Glossary

ROOT: data analysis framework developed at CERN
KalSeed: data product that represents a track
CeEndpoint-mix: dataset name for CeEndpoint (i.e. mono-energetic electrons) with background frames mixed in
CeplusEndpoint-mix: dataset name for CeplusEndpoint (i.e. mono-energetic positrons) with background frames mixed in
flatmugamma-mix: dataset name for flatmugamma (i.e. flate energy photons generated at muon stopping positions) with background frames mixed in
KalFinalFit: the module name for the final stage of the Kalman filter fit for the track
TrkQual: an artificial neural network (ANN) that takes parameters from the track and outputs a value between 0 (poorly reconstructed) and 1 (well-reconstructed)

TrkAnaTutorial

Contents

Session Prerequisites

Session Introduction

Basic Exercises

Setup

Exercise 1: Creating the simplest TrkAna tree

Exercise 2: Calculating the Ce efficiency

Exercise 3: Adding MC truth

Exercise 4: Following genealogy

Exercise 5: Adding supplemental tracks

Exercise 6: TrkAnaReco

Advanced Exercises

Setup

Exercise 1: Looking at the hits in the track

Exercise 2: Analyzing a TrkAna tree with a compiled macro

Exercise 3: Retraining TrkQual

Exercise 4: Adding your own weight module

Exercise 5: Adding your own custom branch to TrkAna

Exercise 6: Creating your own "TrkAna" tree using InfoStructs

Reference Materials

A Useful Glossary

Navigation menu

TrkAnaTutorial

Session Prerequisites

Session Introduction

Basic Exercises

Setup

Exercise 1: Creating the simplest TrkAna tree

Exercise 2: Calculating the Ce efficiency

Exercise 3: Adding MC truth

Exercise 4: Following genealogy

Exercise 5: Adding supplemental tracks

Exercise 6: TrkAnaReco

Advanced Exercises

Setup

Exercise 1: Looking at the hits in the track

Exercise 2: Analyzing a TrkAna tree with a compiled macro

Exercise 3: Retraining TrkQual

Exercise 4: Adding your own weight module

Exercise 5: Adding your own custom branch to TrkAna

Exercise 6: Creating your own "TrkAna" tree using InfoStructs

Reference Materials

A Useful Glossary

Navigation menu

Search