1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
16 /* $Id: AliTRDgtuSim.cxx 28397 2008-09-02 09:33:00Z cblume $ */
18 ////////////////////////////////////////////////////////////////////////////
22 // Authors: J. Klein (Jochen.Klein@cern.ch) //
24 ////////////////////////////////////////////////////////////////////////////
33 #include "TClonesArray.h"
36 #include "AliRunLoader.h"
37 #include "AliLoader.h"
38 #include "AliTreeLoader.h"
40 #include "AliESDTrdTrack.h"
41 #include "AliESDTrdTracklet.h"
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"
52 ClassImp(AliTRDgtuSim)
54 AliTRDgtuSim::AliTRDgtuSim(AliRunLoader *rl)
57 fFeeParam(AliTRDfeeParam::Instance()),
64 AliTRDgtuSim::~AliTRDgtuSim()
69 fTrackletArray->Clear();
70 delete fTrackletArray;
73 Bool_t AliTRDgtuSim::RunGTUFromTrackletFile(TString filename, Int_t event, Int_t noev)
75 // run the GTU from a file of tracklets
76 // used for comparison to VHDL simulation
78 ifstream input(filename.Data());
84 Int_t iEventPrev = -1;
85 Int_t iStackPrev = -1;
95 TClonesArray trklArray("AliTRDtrackletWord", 100);
96 TClonesArray trklArrayGTU("AliTRDtrackletGTU", 100);
98 AliDebug(1, Form("--------- Reading from %s ----------", filename.Data()));
99 while (getline(input, str)) {
103 TObjArray *tokens = string.Tokenize(" ");
104 if (tokens->GetEntriesFast() < 7) {
105 AliWarning(Form("Invalid input in line %i, too few parameters", lineno));
110 if ( ((TObjString*) tokens->At(0))->GetString().Atoi() < event) {
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();
119 if ((iEvent != iEventPrev) ||
120 (iStack != iStackPrev) ||
121 (iSec != iSecPrev)) {
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() ));
132 fTMU = new AliTRDgtuTMU();
136 fTMU = new AliTRDgtuTMU();
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)
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);
155 fTMU->AddTracklet(trkl, iLink);
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);
172 AliInfo(Form("Analyzed %i events", evcnt));
176 Bool_t AliTRDgtuSim::RunGTU(AliLoader *loader, AliESDEvent *esd, Int_t label, Int_t outLabel)
178 // run the GTU on tracklets taken from the loader
179 // if specified the GTU tracks are written to the ESD event
181 if (!fFeeParam->GetTracklet())
185 fTrackletArray->Clear();
188 if (!LoadTracklets(loader)) {
189 AliError("Could not load the tracklets. Nothing done ...");
194 LoadTracklets(esd, label);
197 AliDebug(1, Form("running on %i tracklets", fTrackletArray->GetEntriesFast()));
199 Int_t iStackPrev = -1;
210 TList *listOfTracks = new TList();
212 TIter next(fTrackletArray);
214 while (AliTRDtrackletGTU *trkl = (AliTRDtrackletGTU*) next()) {
215 iSec = trkl->GetDetector() / 30;
216 iStack = (trkl->GetDetector() % 30) / 6;
217 iLink = trkl->GetHCId() % 12;
219 if (iStack != iStackPrev || iSec != iSecPrev) {
221 fTMU->SetStack(iStackPrev);
222 fTMU->SetSector(iSecPrev);
223 fTMU->RunTMU(listOfTracks, 0x0, outLabel);
224 WriteTracksToLoader(listOfTracks);
225 WriteTracksToESD(listOfTracks, esd);
227 listOfTracks->Delete();
229 fTMU = new AliTRDgtuTMU();
233 AliDebug(1, Form("now in sec %i, stack %i", iSec, iStack));
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));
238 fTMU->AddTracklet(trkl, iLink);
243 fTMU->SetStack(iStackPrev);
244 fTMU->SetSector(iSecPrev);
245 fTMU->RunTMU(listOfTracks, 0x0, outLabel);
246 WriteTracksToLoader(listOfTracks);
247 WriteTracksToESD(listOfTracks, esd);
250 listOfTracks->Delete();
258 Bool_t AliTRDgtuSim::LoadTracklets(const AliESDEvent *const esd, Int_t label)
260 AliDebug(1,"Loading tracklets from ESD event ...");
263 fTrackletArray = new TClonesArray("AliTRDtrackletGTU", 1000);
265 for (Int_t iTracklet = 0; iTracklet < esd->GetNumberOfTrdTracklets(); iTracklet++) {
266 AliESDTrdTracklet *trkl = esd->GetTrdTracklet(iTracklet);
268 if (trkl->GetLabel() == label)
269 new ((*fTrackletArray)[fTrackletArray->GetEntries()]) AliTRDtrackletGTU(trkl);
272 if (trkl->GetLabel() >= -1)
273 new ((*fTrackletArray)[fTrackletArray->GetEntries()]) AliTRDtrackletGTU(trkl);
279 Bool_t AliTRDgtuSim::LoadTracklets(AliLoader *const loader)
281 // load the tracklets using the given loader
283 AliDebug(1,"Loading tracklets ...");
285 if (!fFeeParam->GetTracklet())
289 AliError("No loader given!");
293 AliDataLoader *trackletLoader = loader->GetDataLoader("tracklets");
294 if (!trackletLoader) {
295 AliError("No tracklet loader found!");
299 trackletLoader->Load();
300 TTree *trackletTree = 0x0;
302 // simulated tracklets
303 trackletTree = trackletLoader->Tree();
305 TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
308 fTrackletArray = new TClonesArray("AliTRDtrackletGTU", 1000);
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);
322 AliTreeLoader *tl = (AliTreeLoader*) trackletLoader->GetBaseLoader("tracklets-raw");
323 trackletTree = tl ? tl->Load(), tl->Tree() : 0x0;
327 fTrackletArray = new TClonesArray("AliTRDtrackletGTU", 1000);
330 TClonesArray *ar = 0x0;
331 trackletTree->SetBranchAddress("hc", &hc);
332 trackletTree->SetBranchAddress("trkl", &ar);
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));
345 AliError("No raw tracklet tree found\n");
350 Bool_t AliTRDgtuSim::WriteTracksToDataFile(TList *listOfTracks, Int_t event)
352 // write the found tracks to a data file
353 // used for comparison to VHDL simulation
359 out = fopen("test.data", "a");
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();
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);
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);
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),
404 Bool_t AliTRDgtuSim::WriteTracksToESD(const TList * const listOfTracks, AliESDEvent *esd)
406 // fill the found tracks to the given ESD event
409 TIter next(listOfTracks);
410 while (AliTRDtrackGTU *trk = (AliTRDtrackGTU*) next()) {
411 AliESDTrdTrack *trdtrack = trk->CreateTrdTrack();
412 esd->AddTrdTrack(trdtrack);
419 Bool_t AliTRDgtuSim::WriteTracksToLoader(const TList * const listOfTracks)
421 // write the GTU tracks to the dedicated loader
422 // these tracks contain more information than the ones in the ESD
424 AliRunLoader *rl = AliRunLoader::Instance();
425 AliDataLoader *dl = 0x0;
427 dl = rl->GetLoader("TRDLoader")->GetDataLoader("gtutracks");
429 AliError("Could not get the GTU-track data loader!");
433 TTree *trackTree = dl->Tree();
436 trackTree = dl->Tree();
439 AliTRDtrackGTU *trk = 0x0;
441 if (!trackTree->GetBranch("TRDtrackGTU"))
442 trackTree->Branch("TRDtrackGTU", "AliTRDtrackGTU", &trk, 32000);
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);
451 dl->WriteData("OVERWRITE");