Summary of changes:
[u/mrichter/AliRoot.git] / 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     AliInfo("--------- Reading from file ----------");
90     while (getline(input, str)) {
91         lineno++;
92         string = str;
93         AliInfo(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                 AliInfo(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                     AliInfo(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             AliInfo(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   AliInfo("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   AliInfo(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       AliInfo(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     AliInfo(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   AliInfo(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 }