D0root

Introduction	Code design	Install
Vertexing and b-tagging	Missing Et Significance	Top/Higgs analysis
Mailing list

Introduction

Talk given at the data-tier meeting.
The current D0 reconstruction output is an Ntuple built by each Reconstruction and Particle Id. package.

Each event consists of blocks containing float and integers no related each other. For instance:

   Int_t           CH_nch;
   Float_t         CH_chE[100];
   Float_t         CH_cheta[100];
   Float_t         CH_chphi[100];
   Float_t         CH_chpt[100];

   Float_t         MuoGTR_mgtrE[500];
   Float_t         MuoGTR_mgtreta[500];
   Float_t         MuoGTR_mgtrphi[500];
   Float_t         MuoGTR_mgtrpt[500];

   Int_t           PVRECO_prnvtx;
   Float_t         PVRECO_prchisq[100];
   Float_t         PVRECO_prx[100];
   Float_t         PVRECO_pry[100];
   Float_t         PVRECO_prz[100];
   ...

CH: reconstructed charged particle tracks, MuoGTR: reconstructed muons, PVRECO: reconstructed primary vertices, etc.
Very easy to look at variable distributions, like electron pT
Extremely difficult to do complex analysis or to find relations like matching electrons with jets or find the fraction of tracks in common between 2 vertices.
The above tasks often involves chains of loops over different blocks, lots of auxiliary variable arrays, etc.
Altought D0 Reconstruction and ROOT are Object-Oriented, an Ntuple is a data structure (not object-oriented). This means that all physics objects, alive during the event reconstruction, are lost at the time they are stored in the output file.
The idea behind d0root package is to build-up objects out of the Ntuple and make them alive for physics analysis.

d0root package is independent of the input format: it is a general framework for HEP analysis which can be used in any collider experiment. See the following talk for details.

Code design

D0root package provides a set of physics-objects definitions describing the full D0 detector and several algorithms (V0 reconstruction, b-tagging, missing Et significance, qcd background estimators, topological variables, etc.) for physics analysis.
Since all user's code using d0root framework is based on objects, it is independent on the original ntuple variables. If the input ntuple changes, only 1 class is required to change: ReadEvent which has the responsibility of reading the ntuple and creating the objects. All the physics analysis code will work independently of the ntuple variable definitions.
The framework is organized in the following way:
1. d0root_analysis:
  - objects: physics objects definitions
  - algorithms: algorithm definitions.
  - read_event: class to read the ntuple and create objects
2. d0root_btag
  - analysis
  - macros
3. d0root_met
  - analysis
  - macros
4. d0root_top
  - analysis
  - macros
Analysis classes are defined in the analysis directory. The result of any method is a root file containing histograms.
macros directory contains macros to make plots out of the root files created by the analysis classes.

Physics Objects

All physics objects derive from the abstract class Particle which is a subclass of TLorentzVector. Since Particle interface is shared for all the objects, this section describes the main features of it in detail. Next figure shows the Particle class definition:

class Particle : public TLorentzVector { public: /// constructors Particle(); Particle(double px, double py, double pz, double E, double z, int id = 0); Particle(TLorentzVector p, double z, int id = 0); /// destructor ~Particle(); /// int Id(); /// double Z(); /// double DeltaZ(Particle& aParticle); /// double PtRel(Particle* aJet); /// Particle* MatchId(TObjArray& particles); /// Particle* Match(TObjArray& particles, double DR = 0.3, double DZ = 1.5); /// Particle* GetBackToBack(TObjArray& particles, double DR = 2.5); /// definitions for HADcal objects bool IsCentral(); bool IsICR(); bool IsForward(); /// definitions for EMcal objects bool IsCC(); bool IsEC(); ///object quality Quality GetQuality(); //quality must be implemented by subclasses. virtual void SetQuality(); /// virtual void print(); /// virtual void draw(int color = 4, int style = 1); /// re-vertex virtual void ReVertex(float& zvtx); /// energy smearing virtual void Smear(TRandom* randomGenerator); /// energy resolution virtual float EnergyResolution(); /// float Cosine(float& METx, float& METy); }

Since Particle derives from TLorentzVector, all physics objects have the following methods (among others) available:

double Px()
double Py()
double Pz()
double P()
double E()
double M()
double Pt()
double Phi()
double Eta()
double DeltaR(aParticle&)

the method Match(TObjArray& particles) can be used to match (in eta,phi,z) any objects with a list of objects. For instance:

EMparticle* e = (EMparticle*) jet->Match(listOfElectrons);

will find the closest electron to the jet.

every physics-object defines its Quality in SetQuality() method. One object can have more than 1 quality and different qualities for the simulation and the data. It is accessed, for instance, by:

int q = jet->GetQuality().Value("DATA");

where q is an integer. By default, q=0 means that the object do not pass the selection criteria, q=1 means a loose cut and q=2 corresponds to a tight cut.
User's can add as many level of qualities as wanted.

The importance of defining the physics-object quality in every class, is that we can select ANY physics-object list simply by doing:

  TObjArray selectedList;
  for(int i=0; i < objectList; i++) {
    Particle* p = (Particle*) objectList[i];
    if(p->GetQuality().Value("DATA")>=1) selectedList.Add(p);
  }

where we don't have to specify what kind object (class) we are trying to select.

the virtual method Revertex(f loat& zvtx) changes the momentum and energy of the particle assuming it comes from a vertex with z-position given by zvtx.
It is a virtual method which means that every physics object implements it.

Every object implements the method EnergyResolution which returns sigma(Pt) for the particular object. Note that it is not limited to be a function of eta and energy. It can a function of any object variable. See Jet class implementation for an example.

The method Smear allows to change the momentum and energy of the particle randomly according to its resolution. Any dpf distribution can be used. See Jet class implementation for an example.

The method draw displays the object in a canvas. This allows to build an Event Display by simply calling the draw method of every object the user wants to display.

Physics object definitions can be found in the Class index

Mailing List

There is a listserv D0ROOT_PACKAGES mailing list to discuss issues about d0root code, suggest new improvements/changes, and keep users informed about new versions and modifications.

To subscribe to this list, please send an Email to listserv@fnal.gov with the following body:

 subscribe D0ROOT_PACKAGES your-first-name your-last-name

Install

Follow the instructions given at the following link . -Click on the latest version-

Examples

Examples can be found in d0root_btag, d0root_met and d0root_top directories.
Please look at these files to learn how to use this package.

An example to analyze J/Psi and B+ vertex decays is given at the following link

Hints

The methods to read and select events are defined in the class d0root_analysis/read_event/ReadEvent.h
Please look at this file to see all available methods.
Look at more complicated examples in d0root_btag/analysis/ and d0root_met/analysis/

D0 note [in progress]

Contributions

D0root packages contain code developed by:

Brad Abbott.
Phil Gutierrez
Robert Illingworth.
Suyong Choi
Vivek Jain.
Rick Van Kooten and Abaz Kryemadhi.
Don Lincoln.
Monika Linker.
Elmer Nagy, Alex Cothenet and Eric Thomas.
Marian Zidrazil.
Xiaojian Zhang.
Frank Filthaut.
Meenakshi Narain.
Christos Leonidopoulos.

Many thanks to Philippe Canal for his help in the development of this package

Last updated: Wed Nov 27 23:32:24 CST 2002

Ariel Schwartzman