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