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