MUON/AliMUONRecoEvent.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17 $Log$
  18 Revision 1.2  2000/11/23 10:09:38  gosset
  19 Bug correction in AliMUONRecoDisplay.
  20 Copyright, $Log$, $Id$, comments at the right place for automatic documentation,
  21 in AliMUONRecoEvent and AliMUONRecoDisplay
  22
  23 */
  24
  25 //Authors: Mihaela Gheata, Andrei Gheata 09/10/00
  26 ////////////////////////////////////////////////////////////////////
  27 //                                                                //
  28 // AliMUONRecoEvent, AliMUONRecoTrack (and AliMUONRecoDisplay)    //
  29 //                                                                //
  30 // Theses classes are used to store and retrieve                  //
  31 // MUON reconstructed events.                                     //
  32 // The corresponding tree is constructed and filled               //
  33 // during the FillEvent() method of AliMUONEventReconstructor,    //
  34 // when all reconstruction information is available.              //
  35 //                                                                //
  36 ////////////////////////////////////////////////////////////////////
  37 ////////////////////////////////////////////////////////////////////
  38 //                                                                //
  39 // AliMUONRecoEvent                                               //
  40 //                                                                //
  41 // This class handles an array of reconstructed tracks.           //
  42 // It provides :                                                  //
  43 //      - filling the tracks array according to the information   //
  44 //        stored in AliMUONEventReconstructor class ;             //
  45 //      - printing event and track informations : event numer,    //
  46 //        number of tracks, hits positions, reconstr. mometum.    //
  47 //                                                                //
  48 ////////////////////////////////////////////////////////////////////
  49 ////////////////////////////////////////////////////////////////////
  50 //                                                                //
  51 // AliMUONRecoTrack                                               //
  52 //                                                                //
  53 // This class represents a reconstructed muon track               //
  54 // in the tree of reconstructed events.                           //
  55 //                                                                //
  56 ////////////////////////////////////////////////////////////////////
  57
  58 #include <iostream.h>
  59 #include <AliRun.h>
  60 #include <TClonesArray.h>
  61 #include "AliMUONRecoEvent.h"
  62 #include "AliMUONTrack.h"
  63 #include "AliMUONTrackParam.h"
  64 #include "AliMUONHitForRec.h"
  65 #include "AliMUONTrackHit.h"
  66
  67 ClassImp(AliMUONRecoTrack)
  68 ClassImp(AliMUONRecoEvent)
  69
  70 //-------------------------------------------------------------------
  71 AliMUONRecoEvent::AliMUONRecoEvent(Int_t eventNo)
  72 {
  73 // Reconstructed event constructor
  74    fTracks      = new TClonesArray("AliMUONRecoTrack",200);
  75    fNevr        = eventNo;
  76    fNtracks = 0;
  77 }
  78
  79 //-------------------------------------------------------------------
  80 AliMUONRecoEvent::~AliMUONRecoEvent()
  81 {
  82 // Destructor of AliMUONRecoEvent
  83    fTracks->Delete();
  84    delete fTracks;
  85    fTracks = 0;
  86 }
  87
  88 //-------------------------------------------------------------------
  89 AliMUONRecoTrack* AliMUONRecoEvent::AddEmptyTrack()
  90 {
  91 // Add a empty AliMUONRecoTrackObject to the track list
  92    TClonesArray &dumptracks = *fTracks;
  93    return (new(dumptracks[fNtracks++])AliMUONRecoTrack(kTRUE));
  94 }
  95
  96 //-------------------------------------------------------------------
  97 void AliMUONRecoEvent::Clear(Option_t *option)
  98 {
  99 // Clears all track pointers from the list
 100 //   fTracks->Clear(option);
 101    fTracks->Delete();
 102    fNtracks=0;
 103 }
 104
 105 //-------------------------------------------------------------------
 106 void AliMUONRecoEvent::EventInfo()
 107 {
 108 // Prints reconstructed event information
 109    cout << "*********************Reco Dumper**************************" << endl;
 110    cout << "Event number : " << fNevr << endl;
 111    cout << "   Number of tracks : " << fNtracks << endl;
 112    AliMUONRecoTrack *currentTrack =0;
 113    Int_t trackIndex = 0;
 114    for(trackIndex=0; trackIndex<fNtracks; trackIndex++) {
 115       currentTrack = (AliMUONRecoTrack*)fTracks->UncheckedAt(trackIndex);
 116       cout << "Track : " << trackIndex << endl;
 117       cout << "   Sign : " << currentTrack->GetSign() << endl;
 118       cout << "   Vertex position    : " << currentTrack->GetVertexPos() << endl;
 119       Double_t momreco[3];
 120       for (Int_t axis=0; axis<3; axis++) {
 121          momreco[axis] = currentTrack->GetMomReconstr(axis);
 122       }
 123       cout << "   Reconstructed mom. : " << "Px=" << momreco[0] << "Py=" << momreco[1] << "Pz=" << momreco[2] << endl;
 124       cout << "   Chi squared        : " << currentTrack->GetChi2r() << endl;
 125       cout << "   Hits positions     : " << endl;
 126       Double_t xhit, yhit, zhit;
 127       for (Int_t chamber=0; chamber<10; chamber++) {
 128          xhit = currentTrack->GetPosX(chamber);
 129          yhit = currentTrack->GetPosY(chamber);
 130          zhit = currentTrack->GetPosZ(chamber);
 131 //         cout <<"      chamber" << chamber << " X=" << xhit << " Y=" << yhit << " Z=" << zhit << endl;
 132       }
 133    }
 134    cout << "**********************************************************" << endl;
 135 }
 136
 137 //-------------------------------------------------------------------
 138 Bool_t AliMUONRecoEvent::MakeDumpTracks(TClonesArray *tracksPtr)
 139 {
 140 // This method takes the pointer of the list of reconstructed tracks from
 141 // AliMUONEventReconstructor and fill the reconstructed AliMUONRecoEvent
 142 // fields.
 143         cout << "Enter MakeDumpTracks..." << endl;
 144    Int_t nTracks = tracksPtr->GetEntriesFast();
 145    if (nTracks == 0) {
 146       cout << "AliMUONRecoEvent::MakeDumpTracks: Number of tracks is zero !" << endl;
 147       return kFALSE;
 148    }
 149    cout << tracksPtr << endl;
 150    if (!tracksPtr) {
 151       cout << "AliMUONRecoEvent::MakeDumpTracks() : You should call SetRecoTracksPtr() first..." << endl;
 152       return kFALSE;
 153    }
 154         // Get event number
 155    Int_t noEvent = gAlice->GetHeader()->GetEvent();
 156    tracksPtr->Compress();  // simple loop
 157    AliMUONRecoTrack *currentTrack;
 158    Int_t trackIndex = 0, nTrackHits = 0;
 159    Double_t z,bendingSlope, nonBendingSlope, pYZ;
 160    Double_t pX, pY, pZ;                 // reconstructed momentum components
 161    Int_t isign;                                 // charge sign
 162    AliMUONTrack *track = 0;
 163    AliMUONTrackParam *trackParam = 0;
 164    // Fill event number and number of tracks
 165    fNevr = noEvent;
 166    // Loop over reconstructed tracks
 167    for (trackIndex=0; trackIndex<nTracks; trackIndex++) {
 168       currentTrack = AddEmptyTrack();
 169       track = (AliMUONTrack*) ((*tracksPtr)[trackIndex]);
 170       nTrackHits = track->GetNTrackHits();
 171       trackParam = track->GetTrackParamAtVertex();
 172       bendingSlope = trackParam->GetBendingSlope();
 173       nonBendingSlope = trackParam->GetNonBendingSlope();
 174       z = trackParam->GetZ();
 175       pYZ = 1/TMath::Abs(trackParam->GetInverseBendingMomentum());
 176       pZ = pYZ/TMath::Sqrt(1+bendingSlope*bendingSlope);
 177       pX = pZ * nonBendingSlope;
 178       pY = pZ * bendingSlope;
 179       if (trackParam->GetInverseBendingMomentum()<0) isign=-1; else isign=1;
 180       currentTrack->SetVertexPos(z);
 181       currentTrack->SetMomReconstr(pX,pY,pZ);
 182       currentTrack->SetSign(isign);
 183 //         currentTrack->SetChi2r(trackParam->GetChi2());
 184       currentTrack->SetChi2r(0);
 185       AliMUONTrackHit *trackHit;
 186       Double_t xhit,yhit,zhit;
 187           // Loop over track hits
 188       for (Int_t trackHitIndex = 0; trackHitIndex < nTrackHits; trackHitIndex++) {
 189          trackHit = (AliMUONTrackHit*) (*(track->GetTrackHitsPtr()))[trackHitIndex];
 190          xhit = trackHit->GetHitForRecPtr()->GetNonBendingCoor();
 191          yhit = trackHit->GetHitForRecPtr()->GetBendingCoor();
 192          zhit = trackHit->GetHitForRecPtr()->GetZ();
 193          if (trackHitIndex >= 0 && trackHitIndex < 10) {
 194             currentTrack->SetHitPosition(trackHitIndex,xhit,yhit,zhit);
 195          } else { cout << "track " << trackIndex << " hit out of range" << endl;}
 196       }
 197    }
 198    cout << "Leave MakeDumpTracks..." << endl;
 199    return kTRUE;
 200 }
 201
 202 //-------------------------------------------------------------------
 203 void AliMUONRecoEvent::Streamer(TBuffer &R__b)
 204 {
 205 // Streams an object of class AliMUONRecoEvent
 206    if (R__b.IsReading()) {
 207       Version_t R__v = R__b.ReadVersion(); if (R__v) { }
 208       TObject::Streamer(R__b);
 209       R__b >> fNevr;
 210       R__b >> fNtracks;
 211       fTracks->Clear();
 212       fTracks->Streamer(R__b);
 213    } else {
 214       cout << "...writing event to file...\n";
 215       R__b.WriteVersion(AliMUONRecoEvent::IsA());
 216       TObject::Streamer(R__b);
 217       R__b << fNevr;
 218       R__b << fNtracks;
 219       fTracks->Streamer(R__b);
 220    }
 221 }
 222
 223 //-------------------------------------------------------------------
 224 AliMUONRecoTrack::AliMUONRecoTrack(Bool_t active)
 225 {
 226 //Constructor of AliMUONRecoTrack
 227    fSign  = 0;
 228    fZvr   = 0.0;
 229    fChi2r = 0.0;
 230    if (active) {
 231         for (Int_t axis=0; axis<3; axis++) {
 232         fPr[axis] = 0.0;
 233         }
 234         for (Int_t chamber=0; chamber<10; chamber++) {
 235         fPosX[chamber] = 0.0;
 236         fPosY[chamber] = 0.0;
 237         fPosZ[chamber] = 0.0;
 238         }
 239    }
 240 }
 241
 242 //-------------------------------------------------------------------
 243 const Double_t AliMUONRecoTrack::Phi()
 244 {
 245 // Return trach phi angle
 246         return TMath::ATan2(fPr[2], fPr[1]);
 247 }
 248
 249 //-------------------------------------------------------------------
 250 const Double_t AliMUONRecoTrack::Theta()
 251 {
 252 // Return trach theta angle
 253    return TMath::ACos(fPr[3] / P());
 254 }
 255
 256 //-------------------------------------------------------------------
 257 void AliMUONRecoTrack::SetMomReconstr(Double_t px, Double_t py, Double_t pz)
 258 {
 259 // Set the track reconstructed momentum
 260    fPr[0] = px;
 261    fPr[1] = py;
 262    fPr[2] = pz;
 263 }
 264
 265 //-------------------------------------------------------------------
 266 void AliMUONRecoTrack::SetHitPosition(Int_t chamber, Double_t x, Double_t y, Double_t z)
 267 {
 268 // Set hit coordinates in chamber[0..9]
 269    fPosX[chamber] = x;
 270    fPosY[chamber] = y;
 271    fPosZ[chamber] = z;
 272 }
 273 //-------------------------------------------------------------------
 274 void AliMUONRecoTrack::TrackInfo()
 275 {
 276 // Prints momentum info for this track
 277    cout << "Px=" << GetMomReconstr(0) << " Py=" << GetMomReconstr(1) <<
 278           " Pz=" << GetMomReconstr(2) << " P=" << P() << endl;
 279 }