TRD/AliTRDgtuSim.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 /* $Id: AliTRDgtuSim.cxx 28397 2008-09-02 09:33:00Z cblume $ */
  17
  18 ////////////////////////////////////////////////////////////////////////////
  19 //                                                                        //
  20 //  GTU simulation                                                        //
  21 //                                                                        //
  22 //  Authors: J. Klein (Jochen.Klein@cern.ch)                              //
  23 //                                                                        //
  24 ////////////////////////////////////////////////////////////////////////////
  25
  26 #include <stdio.h>
  27 #include <fstream>
  28 #include <string>
  29
  30 #include "TFile.h"
  31 #include "TROOT.h"
  32 #include "TClonesArray.h"
  33
  34 #include "AliTRDgtuSim.h"
  35 #include "AliTRDmcmTracklet.h"
  36 #include "AliTRDgtuTMU.h"
  37 #include "AliTRDtrackGTU.h"
  38 #include "AliTRDtrackletWord.h"
  39 #include "AliTRDtrackletMCM.h"
  40 #include "AliESDEvent.h"
  41
  42 #include "AliRun.h"
  43 #include "AliRunLoader.h"
  44 #include "AliLoader.h"
  45 #include "AliLog.h"
  46
  47 ClassImp(AliTRDgtuSim)
  48
  49 AliTRDgtuSim::AliTRDgtuSim(AliRunLoader *rl)
  50   : TObject(),
  51   fRunLoader(rl),
  52   fTMU(0x0),
  53   fTrackletArray(0x0),
  54   fTrackTree(0x0),
  55   fTrackletTree(0x0)
  56 {
  57   fTrackletTree = new TTree("gtutracklets", "Tree with GTU tracklets");
  58   fTrackletTree->SetDirectory(0);
  59 }
  60
  61 AliTRDgtuSim::~AliTRDgtuSim()
  62 {
  63   if (fTrackletArray)
  64     fTrackletArray->Delete();
  65   delete fTrackletArray;
  66   delete fTrackletTree;
  67 }
  68
  69 Bool_t AliTRDgtuSim::RunGTUFromTrackletFile(TString filename, Int_t event, Int_t noev)
  70 {
  71     AliInfo(Form("Running the GTU simulation on file: %s", filename.Data()));
  72     ifstream input(filename.Data());
  73
  74     std::string str;
  75     TString string;
  76     int lineno = 0;
  77
  78     Int_t iEventPrev = -1;
  79     Int_t iStackPrev = -1;
  80     Int_t iSecPrev = -1;
  81     Int_t iSec = -1;
  82     Int_t iStack = -1;
  83     Int_t iLink = -1;
  84     Int_t iEvent = -1;
  85     Int_t evcnt = -1;
  86
  87     fTMU = 0x0;
  88
  89     AliDebug(5,"--------- Reading from file ----------");
  90     while (getline(input, str)) {
  91         lineno++;
  92         string = str;
  93         AliDebug(5,Form("Line %i : %s", lineno, string.Data()));
  94
  95         TObjArray *tokens = string.Tokenize(" ");
  96         if (tokens->GetEntriesFast() < 7) {
  97             AliWarning(Form("Invalid input in line %i, too few parameters", lineno));
  98             continue;
  99         }
 100
 101         if ( ((TObjString*) tokens->At(0))->GetString().Atoi() < event)
 102             continue;
 103
 104         iEvent = ((TObjString*) tokens->At(0))->GetString().Atoi();
 105         iSec = ((TObjString*) tokens->At(1))->GetString().Atoi();
 106         iStack = ((TObjString*) tokens->At(2))->GetString().Atoi();
 107         iLink = 2 * ((TObjString*) tokens->At(3))->GetString().Atoi() + ((TObjString*) tokens->At(4))->GetString().Atoi();
 108
 109         if (iEvent != iEventPrev || iStack != iStackPrev || iSec != iSecPrev) {
 110             if(fTMU) {
 111                 TList *ListOfTracks = new TList();
 112                 fTMU->SetStack(iStackPrev);
 113                 fTMU->SetSector(iSecPrev);
 114                 fTMU->RunTMU(ListOfTracks);
 115                 AliDebug(1,Form("--- There are %i tracks. Writing ...", ListOfTracks->GetEntries()));
 116                 WriteTracksToTree(ListOfTracks);
 117                 fTMU->WriteTrackletsToTree(fTrackletTree);
 118                 WriteTracksToDataFile(ListOfTracks, iEventPrev);
 119                 if (ListOfTracks->GetEntries() > 0)
 120                     AliDebug(2,Form("   %d GeV/c", ((AliTRDtrackGTU*) ListOfTracks->At(0))->GetPt() ));
 121                 delete fTMU;
 122                 fTMU = new AliTRDgtuTMU();
 123                 delete ListOfTracks;
 124                 ListOfTracks = 0x0;
 125             } else {
 126                 fTMU = new AliTRDgtuTMU();
 127             }
 128             iStackPrev = iStack;
 129             iSecPrev = iSec;
 130             iEventPrev = iEvent;
 131             evcnt++;
 132             if (evcnt == noev)
 133                 break;
 134         }
 135         for (Int_t i = 5; i < tokens->GetEntriesFast(); i++) {
 136             UInt_t trackletWord = 0;
 137             sscanf(((TObjString*) tokens->At(i))->GetString().Data(), "%x", &trackletWord);
 138             if (trackletWord == 0x10001000)
 139                 break;
 140             AliDebug(2,Form("%i. tracklet: %s -> 0x%08x", i-4, ((TObjString*) tokens->At(i))->GetString().Data(), trackletWord));
 141             AliTRDtrackletWord *trkl = new AliTRDtrackletWord(trackletWord);
 142             fTMU->AddTracklet(trkl, iLink);
 143         }
 144     }
 145
 146     if (fTMU && evcnt < noev) {
 147         TList *ListOfTracks = new TList();
 148         fTMU->SetStack(iStackPrev);
 149         fTMU->SetSector(iSecPrev);
 150         fTMU->RunTMU(ListOfTracks);
 151         WriteTracksToTree(ListOfTracks);
 152         fTMU->WriteTrackletsToTree(fTrackletTree);
 153         WriteTracksToDataFile(ListOfTracks, iEventPrev);
 154         delete fTMU;
 155         delete ListOfTracks;
 156         fTMU = 0x0;
 157     }
 158
 159     AliInfo(Form("Analyzed %i events", evcnt));
 160     return kTRUE;
 161 }
 162
 163 Bool_t AliTRDgtuSim::RunGTU(AliLoader *loader, AliESDEvent *esd)
 164 {
 165     if (!LoadTracklets(loader)) {
 166         AliError("Could not load the tracklets. Aborting ...");
 167         return kFALSE;
 168     }
 169
 170     Int_t iStackPrev = -1;
 171     Int_t iSecPrev = -1;
 172     Int_t iSec = -1;
 173     Int_t iStack = -1;
 174     Int_t iLink = -1;
 175
 176     if (fTMU) {
 177         delete fTMU;
 178         fTMU = 0x0;
 179     }
 180
 181     TList *ListOfTracks = new TList();
 182
 183     TIter next(fTrackletArray);
 184     AliTRDtrackletBase *trkl;
 185
 186     while ((trkl = (AliTRDtrackletBase*) next())) {
 187         iSec = trkl->GetDetector() / 30;
 188         iStack = (trkl->GetDetector() % 30) / 6;
 189         iLink = 2 * (trkl->GetDetector() % 6) + (trkl->GetYbin() < 0 ? 0 : 1);
 190
 191         if (iStack != iStackPrev || iSec != iSecPrev) {
 192             if(fTMU) {
 193                 fTMU->SetStack(iStackPrev);
 194                 fTMU->SetSector(iSecPrev);
 195                 fTMU->RunTMU(ListOfTracks);
 196                 WriteTracksToTree(ListOfTracks);
 197                 fTMU->WriteTrackletsToTree(fTrackletTree);
 198                 WriteTracksToESD(ListOfTracks, esd);
 199                 fTMU->Reset();
 200                 ListOfTracks->Delete();
 201             } else {
 202                 fTMU = new AliTRDgtuTMU();
 203             }
 204             iStackPrev = iStack;
 205             iSecPrev = iSec;
 206         }
 207         fTMU->AddTracklet(trkl, iLink);
 208     }
 209
 210     if (fTMU) {
 211         fTMU->SetStack(iStackPrev);
 212         fTMU->SetSector(iSecPrev);
 213         fTMU->RunTMU(ListOfTracks);
 214         WriteTracksToTree(ListOfTracks);
 215         fTMU->WriteTrackletsToTree(fTrackletTree);
 216         WriteTracksToESD(ListOfTracks, esd);
 217         delete fTMU;
 218         fTMU = 0x0;
 219         ListOfTracks->Delete();
 220     }
 221
 222     delete ListOfTracks;
 223
 224     return kTRUE;
 225 }
 226
 227 Bool_t AliTRDgtuSim::LoadTracklets(AliLoader *loader)
 228 {
 229   AliDebug(1,"Loading tracklets ...");
 230
 231   if (!loader) {
 232     AliError("No loader given!");
 233     return kFALSE;
 234   }
 235
 236   AliDataLoader *trackletLoader = loader->GetDataLoader("tracklets");
 237   if (!trackletLoader) {
 238       AliError("No tracklet loader found!");
 239       return kFALSE;
 240   }
 241
 242   trackletLoader->Load();
 243
 244   TTree *trackletTree = trackletLoader->Tree();
 245   if (!trackletTree) {
 246     AliError("No tracklet tree found");
 247     return kFALSE;
 248   }
 249
 250
 251   TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
 252   if (trklbranch) {
 253       if (!fTrackletArray)
 254           fTrackletArray = new TClonesArray("AliTRDtrackletMCM", 1000);
 255       else if ((TClass::GetClass("AliTRDtrackletMCM"))->InheritsFrom(fTrackletArray->Class()))
 256           fTrackletArray->Delete();
 257       else {
 258           fTrackletArray->Delete();
 259           delete fTrackletArray;
 260           fTrackletArray = new TClonesArray("AliTRDtrackletMCM", 1000);
 261       }
 262
 263       AliTRDtrackletMCM *trkl = new AliTRDtrackletMCM;
 264       trklbranch->SetAddress(&trkl);
 265       for (Int_t iTracklet = 0; iTracklet < trklbranch->GetEntries(); iTracklet++) {
 266           trklbranch->GetEntry(iTracklet);
 267           new ((*fTrackletArray)[fTrackletArray->GetEntries()]) AliTRDtrackletMCM(*trkl);
 268       }
 269       return kTRUE;
 270   }
 271
 272   trklbranch = trackletTree->GetBranch("trkbranch");
 273
 274   if (!trklbranch) {
 275       AliError("Could not get trkbranch");
 276       return kFALSE;
 277   }
 278
 279   if (!fTrackletArray)
 280       fTrackletArray = new TClonesArray("AliTRDtrackletWord", 1000);
 281   else if ((TClass::GetClass("AliTRDtrackletWord"))->InheritsFrom(fTrackletArray->Class()))
 282       fTrackletArray->Delete();
 283   else {
 284       fTrackletArray->Delete();
 285       delete fTrackletArray;
 286       fTrackletArray = new TClonesArray("AliTRDtrackletWord", 1000);
 287   }
 288
 289   Int_t notrkl = 0;
 290   UInt_t *leaves = new UInt_t[258];
 291   AliDebug(1,Form("No. of entries: %i", trklbranch->GetEntries()));
 292
 293   for (Int_t iEntry = 0; iEntry < trklbranch->GetEntries(); iEntry++) {
 294       trklbranch->SetAddress(leaves);
 295       trklbranch->GetEntry(iEntry);
 296       for (Int_t iTracklet = 0; iTracklet < 256; iTracklet++) {
 297         if (leaves[2 + iTracklet] == 0)
 298           break;
 299         new((*fTrackletArray)[notrkl]) AliTRDtrackletWord(leaves[2 + iTracklet], leaves[0] + leaves[1]);
 300         notrkl++;
 301       }
 302       AliDebug(2,Form("Entry: %3i: Det: %3i, side: %i, 1st tracklet: 0x%08x, no: %i", iEntry, leaves[0], leaves[1], leaves[2], notrkl));
 303   }
 304
 305   return kTRUE;
 306 }
 307
 308 Bool_t AliTRDgtuSim::WriteTracksToDataFile(TList *ListOfTracks, Int_t event)
 309 {
 310     Int_t sm = 0;
 311     Int_t stack = 0;
 312
 313     FILE *out;
 314     out = fopen("test.data", "a");
 315
 316     AliDebug(1,Form("%i tracks found in event %i", ListOfTracks->GetSize(), event));
 317     fprintf(out, "0 %5i %2i %i  00000000\n", event, sm, stack);
 318     for (Int_t i = 0; i < ListOfTracks->GetSize(); i++) {
 319         AliTRDtrackGTU *trk = (AliTRDtrackGTU*) ListOfTracks->At(i);
 320         sm = trk->GetSector();
 321         stack = trk->GetStack();
 322         fprintf(out, "1 %5i %2i %2i %3i %3i %3i %3i %3i %3i %3i %4i %f\n", event, sm, stack, trk->GetTrackletMask(),
 323                trk->GetTrackletIndex(5),
 324                trk->GetTrackletIndex(4),
 325                trk->GetTrackletIndex(3),
 326                trk->GetTrackletIndex(2),
 327                trk->GetTrackletIndex(1),
 328                trk->GetTrackletIndex(0),
 329                trk->GetPtInt(),
 330                trk->GetPt());
 331     }
 332     fclose(out);
 333     return kTRUE;
 334 }
 335
 336 Bool_t AliTRDgtuSim::WriteTracksToTree(TList *ListOfTracks, Int_t /*event*/)
 337 {
 338   AliDebug(1,Form("Writing %i tracks to the tree...", ListOfTracks->GetEntries()));
 339
 340   if (!ListOfTracks)
 341     return kFALSE;
 342
 343   if (ListOfTracks->GetEntries() <= 0)
 344     return kTRUE;
 345
 346   if (!fTrackTree) {
 347     fTrackTree = new TTree("gtutracks", "GTU tracks");
 348     fTrackTree->SetDirectory(0);
 349   }
 350
 351   AliTRDtrackGTU *trk = 0x0;
 352   TBranch *branch = fTrackTree->GetBranch("TRDgtuTrack");
 353   if (!branch) {
 354       branch = fTrackTree->Branch("TRDgtuTrack", "AliTRDtrackGTU", &trk, 32000, 99);
 355   }
 356
 357   TIter next(ListOfTracks);
 358   while ((trk = (AliTRDtrackGTU*) next())) {
 359       trk->CookLabel();
 360       branch->SetAddress(&trk);
 361       fTrackTree->Fill();
 362   }
 363   fTrackTree->ResetBranchAddress(branch);
 364
 365   return kTRUE;
 366 }
 367
 368 Bool_t AliTRDgtuSim::WriteTreesToFile() {
 369   TFile *f = TFile::Open("TRD.GtuTracking.root", "RECREATE");
 370   f->cd();
 371   if (fTrackTree)
 372     f->WriteTObject(fTrackTree);
 373   if (fTrackletTree)
 374     f->WriteTObject(fTrackletTree);
 375   f->Close();
 376   return kTRUE;
 377 }
 378
 379 Bool_t AliTRDgtuSim::WriteTracksToESD(TList *ListOfTracks, AliESDEvent *esd)
 380 {
 381     if (esd) {
 382         TIter next(ListOfTracks);
 383         while (AliTRDtrackGTU *trk = (AliTRDtrackGTU*) next()) {
 384             AliESDTrdTrack *trdtrack = trk->CreateTrdTrack();
 385             esd->AddTrdTrack(trdtrack);
 386             delete trdtrack;
 387         }
 388     }
 389     return kTRUE;
 390 }
 391
 392 Bool_t AliTRDgtuSim::WriteTracksToLoader()
 393 {
 394   if (!fTrackTree) {
 395     AliError("No track tree found!");
 396     return kFALSE;
 397   }
 398
 399   AliRunLoader *rl = AliRunLoader::Instance();
 400   AliDataLoader *dl = 0x0;
 401   if (rl)
 402     dl = rl->GetLoader("TRDLoader")->GetDataLoader("gtutracks");
 403   if (!dl) {
 404     AliError("Could not get the GTU-track data loader!");
 405     return kFALSE;
 406   }
 407
 408   TTree *trackTree = dl->Tree();
 409   if (!trackTree) {
 410     dl->MakeTree();
 411     trackTree = dl->Tree();
 412   }
 413
 414   AliTRDtrackGTU *trk = 0x0;
 415   TBranch *trkbranch = trackTree->GetBranch("TRDtrackGTU");
 416   if (!trkbranch)
 417     trkbranch = trackTree->Branch("TRDtrackGTU", "AliTRDtrackGTU", &trk, 32000);
 418
 419   TBranch *branch = fTrackTree->GetBranch("TRDgtuTrack");
 420   if (!branch)
 421     return kFALSE;
 422
 423   AliDebug(1,Form("Found %i tracks", branch->GetEntries()));
 424
 425   for (Int_t iTrack = 0; iTrack < branch->GetEntries(); iTrack++) {
 426     branch->SetAddress(&trk);
 427     branch->GetEntry(iTrack);
 428     trkbranch->SetAddress(&trk);
 429     trackTree->Fill();
 430   }
 431
 432   dl->WriteData("OVERWRITE");
 433
 434   return kTRUE;
 435 }