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