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