Web page of the FIRST experiment reconstruction software

Before starting

The code is developed in C++. It has been tested on several different linux platforms. You need to have ROOT installed. You can have a look at the Documentation Page or the Download page in the ROOT site, to get the basics instructions on how to get compile and install ROOT. After the ROOT installation you might also want to setup the environment variables that allow the ROOT setup to be used in the following. In case you use bash shell you can use.

export ROOTSYS=/path/to/your/root/installation
export LD_LIBRARY_PATH=$ROOTSYS/lib
export PATH=$PATH:$ROOTSYS/bin

FIRST software web interface

The full software project can be browsed trough a web interface (trac based)

How to get the code and compile it.

• The code is available through svn (see SVN gsi page for details)
• The project is described and instructions are given in the main software page.

Once you have followed the instructions given here to compile all the common libs you can proceed trying to compile and run the High level reconstruction algorithms.

hlreco

The high level reconstruction takes as input the output of the level 0 decoding of raw data or MC. So you first need to execute the decoding algorithms and executables (see l0reco and l0mcreco links on top of that) and then you can run the high level reconstruction on the output root file.

Making the executable

In order to be able to compile the high level reconstruction you need a Kalman Filtering package that is open source: KalTest. You need to follow the installation instructions given in the web page and once you have managed to compile the software you need to update the setup script that is kept in hlreco directory (myLogin.sh) setting up the environment variables that need to point to your local installation of KalTest:

export KALTESTINC=/path_to_your/KalTest/include
export KALTESTLIB=/path_to_your/KalTest/lib

Then you can compile the hlreco project (use myLogin.csh if you use (t)csh shells)

cd hlreco
source myLogin.sh
make clean
make HlReco

Running the High level reconstruction

First of all you need to have a root file generated by the DecodeRaw executable. All the informations from all the detectors has to be available (tracking in the vertex has to be enabled). Instruction on how to do that are in this page (that contains the instructions on how to compile the decoder) and scrolling down the page in order to run the decoder on a single set of files.

To run the High level reconstruction you need to provide:

• input file
• number of events
• output root file

An example to run on DATA is

./HlReco -in /s/asarti/production_0476_hltest_vtx.root -run 476 -out myhltest.root -outh myhltest_histo.root -nev 100

An example to run on MC is

./HlReco -in ../l0mcreco/carbonv58_test.root -out HlReco_carb_v56.root -outh HlReco_carb_v56_histo.root -mc -nev 30000

HL reconstruction details

The code is organized as follows:

• The reconstruction sequence is initialized (HlRecoTools::SetupInit)
• The actions are defined (HlRecoTools::SetupTracking and HlRecoTools::SetupReco)
• The event Loop is run (HlRecoTools::Loop)
• Output file is closed

Setup Init

Defines the Data descriptors. Defines the actions for reading the data input specified in Setup Init. Initialize the geometry.

Setup Tracking

Defines the action that actually performs the PER EVENT tracking:

  TAGaction* my_acttrk = new TAGactGlbTracking("my_acttrk",myn_glbtr,myn_info
        ,myn_vtrk,myn_traw,myp_tofgeo);

Returns :

• The global tracks pointer

Takes as input:

• Event info
• Vertex tracks
• Tof wall info
• Tof Geometry

Loop

The event display are initialized. The the tracking, Magnetic field and GlobalTrack classes are initialized:

  Tracking myTrk;
  myTrk.init_fieldmap(); // initialise the fieldmap to zero
  myTrk.init_geometry(); // precalculate same geometry parameters
  myTrk.fill_field(2500); // fill the field map with current 1

For each event:

• the action is executed
• the event display is created

Magnetic Field

The value of the current is HARDCODED in the TAGactGlbTracking.cxx constructor.

  Double_t AladinCurrent=700.;
  //   Double_t AladinCurrent=1000.;
  //   Double_t AladinCurrent=2500.;
  MagneticField *Field = new MagneticField(AladinCurrent);
  GlobalTrack *GloTrack = new GlobalTrack(Field);//TODO: stuff geo info in here

The magnet geometry and acceptance are defined in the Tracjectory Class (Begin of run)

The tracking Class.

The global tracking in the FIRST experiment is performed by the TAGactGlbTracking.cxx action defined in TAGfirst. All the helper classes and the methods are kept in TAGfirst.

• The actGlbTracking actions: set up the magnet field. Calls the tracker class (GlobalTrack)
• The GlobalTrack class: builds the vector of track candidates calling the method MakeGlobalTracksForward
• The method MakeGlobalTracksForward takes as input the vertex tracks and the TOF hits and produces as output a list of candidate tracks

All those methods and classes are described below.

TAGactGlbTracking

The class tha provides as output the TAGntuGlbTracks that are the result of a global tracking. The magnet is setup in the constructor.

  Double_t AladinCurrent=700.;
  //   Double_t AladinCurrent=1000.;
  //   Double_t AladinCurrent=2500.;
  MagneticField *Field = new MagneticField(AladinCurrent);
  GlobalTrack *GloTrack = new GlobalTrack(Field);//TODO: stuff geo info in here

GlobalTrack

ONLY FORWARD TRACKS ARE BUILT, since no Music was available. Tracks are hence built using

void GlobalTrack::MakeGlobalTracksForward(TAGntuEventInfo* on_info,
      TAVTntuTrack* on_vttrk, TATntuRaw* on_traw, TATparGeo* p_tofgeo)

The tracking algorithm

The real tracking algorithm is MakeGlobalTracksForward that is kept inside the GlobalTrack class (TAGfirst folder).

The algorithm structure is the following:

• Informations from the ToF wall are loaded and used to create a 'Tof Wall track candidate' named AladinTrackCandidate (that basically are the TofWall hits).
• Tracks from the Vertex are loaded and extrapolated towards Aladin magnet. If the track goes INSIDE the magnet than we proceed trying the matching.
• The Track from the Vertex is then extrapolated towards the Tof Wall using the TrackForward method of the Trajectory class. If the extrapolation works, than the track is saved to check the matching with the TofWall hits.
  • Trackforward is checking for a match using the TrackableParticle class (method IsParticleInIP)
• Matching is then checked with MakeForwardTrackedMatches from the GlobalTrack class.

-- AlessioSarti - 30 Apr 2012