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