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