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