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