EVE/alice-macros/MUON_display.C

   1 // $Id$
   2 // Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
   3
   4 /**************************************************************************
   5  * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
   6  * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
   7  * full copyright notice.                                                 *
   8  **************************************************************************/
   9
  10 class AliEveMUONData;
  11 class AliEveEventManager;
  12
  13 AliEveMUONData     *g_muon_data       = 0;
  14 AliEveEventManager *g_muon_last_event = 0;
  15
  16 Int_t  g_currentEvent = -1;
  17 Bool_t g_fromRaw      = kFALSE;
  18
  19
  20 void MUON_display(Bool_t fromRaw = kFALSE, Bool_t showTracks = kTRUE)
  21 {
  22   if (!AliMpSegmentation::Instance()) AliMpCDB::LoadMpSegmentation();
  23   if (!AliMpDDLStore::Instance())     AliMpCDB::LoadDDLStore();
  24
  25   TTree* dt = 0;
  26   TTree* ct = 0;
  27   TTree* ht = 0;
  28
  29   if (gEvent == 0) {
  30     printf("No alieve event: use alieve_init(...) \n");
  31     return;
  32   }
  33
  34   if (g_currentEvent == gEvent->GetEventId()) {
  35     if (g_fromRaw == fromRaw) {
  36       printf("Same event... \n");
  37       return;
  38     } else {
  39       if (g_fromRaw) {
  40         printf("Same event with digits.\n");
  41         gEvent->GotoEvent(g_currentEvent);
  42       } else {
  43         printf("Same event with raw.\n");
  44         gEvent->GotoEvent(g_currentEvent);
  45       }
  46     }
  47   }
  48
  49   g_fromRaw = fromRaw;
  50
  51   TString dataPath = TString(gEvent->GetTitle());
  52   dataPath.Append("/rawmuon.root");
  53
  54   AliRunLoader* rl =  AliEveEventManager::AssertRunLoader();
  55   g_muon_data = new AliEveMUONData;
  56
  57   if (!fromRaw) {
  58     rl->LoadDigits("MUON");
  59     dt = rl->GetTreeD("MUON", false);
  60     if (dt == 0) {
  61       cout << "No digits produced!" << endl;
  62     } else {
  63       cout << "With aliroot digits!" << endl;
  64       g_muon_data->LoadDigits(dt);
  65     }
  66   } else {
  67     if (gSystem->AccessPathName(dataPath.Data(),kFileExists)) {
  68       cout << "No raw data produced!" << endl;
  69     } else {
  70       cout << "With raw digits!" << endl;
  71       g_muon_data->LoadRaw(dataPath.Data());
  72     }
  73   }
  74
  75   rl->LoadRecPoints("MUON");
  76   ct = rl->GetTreeR("MUON", false);
  77   g_muon_data->LoadRecPoints(ct);
  78
  79   rl->LoadHits("MUON");
  80   ht = rl->GetTreeH("MUON", false);
  81   g_muon_data->LoadHits(ht);
  82
  83   g_muon_last_event = gEvent;
  84
  85   g_currentEvent = g_muon_last_event->GetEventId();
  86
  87   gStyle->SetPalette(1, 0);
  88
  89   gEve->DisableRedraw();
  90
  91   TEveElementList* l = new TEveElementList("MUONChambers");
  92   l->SetTitle("MUON chambers");
  93   l->SetMainColor(Color_t(2));
  94   gEve->AddElement(l);
  95
  96   for (Int_t ic = 0; ic < 14; ic++)
  97   {
  98     AliEveMUONChamber* mucha = new AliEveMUONChamber(ic);
  99
 100     mucha->SetFrameColor(2);
 101     mucha->SetChamberID(ic);
 102
 103     mucha->SetDataSource(g_muon_data);
 104
 105     gEve->AddElement(mucha, l);
 106   }
 107
 108   if (showTracks) {
 109     MUON_tracks();
 110     MUON_trigger_tracks();
 111     MUON_ESD_tracks();
 112     MUON_Ref_tracks();
 113     MUON_MC_tracks();
 114   }
 115
 116   gEve->Redraw3D(kTRUE);
 117   gEve->EnableRedraw();
 118 }
 119
 120 //______________________________________________________________________________
 121 void MUON_tracks()
 122 {
 123   AliRunLoader* rl =  AliEveEventManager::AssertRunLoader();
 124   rl->LoadTracks("MUON");
 125   TTree* tt = rl->GetTreeT("MUON", false);
 126
 127   TClonesArray *tracks = 0;
 128   tt->SetBranchAddress("AliEveMUONTrack",&tracks);
 129   tt->GetEntry(0);
 130
 131   Int_t ntracks = tracks->GetEntriesFast();
 132   //printf("Found %d tracks. \n",ntracks);
 133
 134   TEveTrackList* lt = new TEveTrackList("M-Tracks");
 135   lt->SetMainColor(Color_t(6));
 136   //lt->SetMUON();
 137
 138   gEve->AddElement(lt);
 139
 140   TMatrixD smatrix(2,2);
 141   TMatrixD sums(2,1);
 142   TMatrixD res(2,1);
 143
 144   Float_t xRec, xRec0;
 145   Float_t yRec, yRec0;
 146   Float_t zRec, zRec0;
 147
 148   Float_t zg[4] = { -1603.5, -1620.5, -1703.5, -1720.5 };
 149
 150   AliMUONTrack *mt;
 151   TEveRecTrack  rt;
 152   Int_t count;
 153   for (Int_t n = 0; n < ntracks; n++)
 154   {
 155     count = 0;
 156
 157     mt = (AliMUONTrack*) tracks->At(n);
 158
 159     rt.label = n;
 160
 161     AliEveMUONTrack* track = new AliEveMUONTrack(&rt, lt->GetPropagator());
 162
 163     track->MakeMUONTrack(mt);
 164
 165     gEve->AddElement(track, lt);
 166   }
 167
 168   rl->UnloadTracks("MUON");
 169
 170 }
 171
 172 //______________________________________________________________________________
 173 void MUON_trigger_tracks()
 174 {
 175   AliRunLoader* rl =  AliEveEventManager::AssertRunLoader();
 176   rl->LoadTracks("MUON");
 177   TTree* tt = rl->GetTreeT("MUON", false);
 178
 179   TClonesArray *tracks = 0;
 180   tt->SetBranchAddress("MUONTriggerTrack",&tracks);
 181   tt->GetEntry(0);
 182
 183   Int_t ntracks = tracks->GetEntriesFast();
 184   //printf("Found %d tracks. \n",ntracks);
 185
 186   TEveTrackList* lt = new TEveTrackList("MT-Tracks");
 187   lt->SetMainColor(Color_t(4));
 188   //lt->SetMUON();
 189
 190   gEve->AddElement(lt);
 191
 192   TMatrixD smatrix(2,2);
 193   TMatrixD sums(2,1);
 194   TMatrixD res(2,1);
 195
 196   Float_t xRec, xRec0;
 197   Float_t yRec, yRec0;
 198   Float_t zRec, zRec0;
 199
 200   Float_t zg[4] = { -1603.5, -1620.5, -1703.5, -1720.5 };
 201
 202   AliMUONTriggerTrack *mt;
 203   TEveRecTrack  rt;
 204   Int_t count;
 205   for (Int_t n = 0; n < ntracks; n++)
 206   {
 207     count = 0;
 208
 209     mt = (AliMUONTriggerTrack*) tracks->At(n);
 210
 211     rt.label = n;
 212
 213     AliEveMUONTrack* track = new AliEveMUONTrack(&rt, lt->GetPropagator());
 214
 215     track->MakeMUONTriggerTrack(mt);
 216
 217     gEve->AddElement(track, lt);
 218   }
 219
 220   rl->UnloadTracks("MUON");
 221
 222 }
 223
 224 //______________________________________________________________________________
 225 void MUON_ESD_tracks()
 226 {
 227   AliESDEvent* esd = AliEveEventManager::AssertESD();
 228
 229   TEveTrackList* lt = new TEveTrackList("ESD-Tracks");
 230   lt->SetMainColor(Color_t(6));
 231   //lt->SetMUON();
 232
 233   gEve->AddElement(lt);
 234
 235   AliESDMuonTrack *mt;
 236   TEveRecTrack rt;
 237   Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
 238   for (Int_t n = 0; n < nMuonTracks; n++)
 239   {
 240     mt = esd->GetMuonTrack(n);
 241
 242     rt.label = n;
 243
 244     AliEveMUONTrack* track = new AliEveMUONTrack(&rt, lt->GetPropagator());
 245
 246     track->MakeESDTrack(mt);
 247
 248     gEve->AddElement(track, lt);
 249   }
 250
 251 }
 252
 253 //______________________________________________________________________________
 254 void MUON_Ref_tracks()
 255 {
 256   TString dataPath = TString(gEvent->GetTitle());
 257   dataPath.Append("/");
 258
 259   AliMUONRecoCheck recoCheck(dataPath.Data(),dataPath.Data());
 260   AliMUONVTrackStore* trackRefStore = recoCheck.ReconstructibleTracks(gEvent->GetEventId());
 261   TIter next(trackRefStore->CreateIterator());
 262   AliMUONTrack* trackRef;
 263
 264   TEveTrackList* lt = new TEveTrackList("Ref-Tracks");
 265   lt->SetMainColor(Color_t(6));
 266
 267   gEve->AddElement(lt);
 268
 269   TEveRecTrack rt;
 270   Int_t i = 0;
 271   while ( ( trackRef = static_cast<AliMUONTrack*>(next()) ) )
 272   {
 273     rt.label = i++;
 274
 275     AliEveMUONTrack* track = new AliEveMUONTrack(&rt, lt->GetPropagator());
 276
 277     track->MakeRefTrack(trackRef);
 278
 279     gEve->AddElement(track, lt);
 280   }
 281
 282 }
 283
 284 //______________________________________________________________________________
 285 void MUON_MC_tracks()
 286 {
 287   Double_t RADDEG = 180.0/TMath::Pi();
 288
 289   AliRunLoader* rl =  AliEveEventManager::AssertRunLoader();
 290   rl->LoadKinematics();
 291   AliStack* stack = rl->Stack();
 292
 293   Int_t nPrimary = stack->GetNprimary();
 294   Int_t nTracks  = stack->GetNtrack();
 295
 296   TEveTrackList* lt = new TEveTrackList("MC-Tracks");
 297   lt->SetMainColor(Color_t(6));
 298   //lt->SetMUON();
 299
 300   gEve->AddElement(lt);
 301
 302   Int_t pdgCode;
 303   TParticle *part;
 304   TEveRecTrack rt;
 305
 306   Int_t nHitTracks = g_muon_data->GetNTrackList();
 307   Int_t index;
 308   for (Int_t i = 0; i < nHitTracks; i++)
 309   {
 310     index = g_muon_data->GetTrack(i);
 311     if (index >= nTracks) {
 312       cout << "TEveHit track index larger than number in stack!" << endl;
 313       continue;
 314     }
 315
 316     part = stack->Particle(index);
 317     if (part->P() < 0.001) continue;  // skip momenta < 1.0 MeV/c
 318     rt.label = i;
 319
 320     AliEveMUONTrack* track = new AliEveMUONTrack(&rt, lt->GetPropagator());
 321
 322     track->MakeMCTrack(part);
 323
 324     gEve->AddElement(track, lt);
 325   }
 326
 327   rl->UnloadKinematics();
 328 }
 329