[u/mrichter/AliRoot.git] / TRD / AliTRDgtuSim.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id: AliTRDgtuSim.cxx 28397 2008-09-02 09:33:00Z cblume $ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//  GTU simulation                                                        //
//                                                                        //
//  Authors: J. Klein (Jochen.Klein@cern.ch)                              //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <fstream>
#include <string>

#include "TFile.h"
#include "TROOT.h"
#include "TClonesArray.h"

#include "AliTRDgtuSim.h"
#include "AliTRDmcmTracklet.h"
#include "AliTRDgtuTMU.h"
#include "AliTRDtrackGTU.h"
#include "AliTRDtrackletWord.h"
#include "AliTRDtrackletMCM.h"
#include "AliESDEvent.h"

#include "AliRun.h"
#include "AliRunLoader.h"
#include "AliLoader.h"
#include "AliLog.h"

ClassImp(AliTRDgtuSim)

AliTRDgtuSim::AliTRDgtuSim(AliRunLoader *rl) 
  : TObject(),
  fRunLoader(rl),
  fTMU(0x0),
  fTrackletArray(0x0),
  fTrackTree(0x0),
  fTrackletTree(0x0)
{
  fTrackletTree = new TTree("gtutracklets", "Tree with GTU tracklets");
}

AliTRDgtuSim::~AliTRDgtuSim() 
{
  if (fTrackletArray)
    fTrackletArray->Delete();
  delete fTrackletArray;
  delete fTrackletTree;
}

Bool_t AliTRDgtuSim::RunGTUFromTrackletFile(TString filename, Int_t event, Int_t noev) 
{
    AliInfo(Form("Running the GTU simulation on file: %s", filename.Data()));
    ifstream input(filename.Data());
    
    std::string str;
    TString string;
    int lineno = 0;
    
    Int_t iEventPrev = -1;
    Int_t iStackPrev = -1;
    Int_t iSecPrev = -1;
    Int_t iSec = -1;
    Int_t iStack = -1;
    Int_t iLink = -1;
    Int_t iEvent = -1;
    Int_t evcnt = -1;
    
    fTMU = 0x0;
    
    AliInfo("--------- Reading from file ----------");
    while (getline(input, str)) {
	lineno++;
	string = str;
	AliInfo(Form("Line %i : %s", lineno, string.Data()));
	
	TObjArray *tokens = string.Tokenize(" ");
	if (tokens->GetEntriesFast() < 7) {
	    AliWarning(Form("Invalid input in line %i, too few parameters", lineno));
	    continue;
	}

	if ( ((TObjString*) tokens->At(0))->GetString().Atoi() < event) 
	    continue;

	iEvent = ((TObjString*) tokens->At(0))->GetString().Atoi();
	iSec = ((TObjString*) tokens->At(1))->GetString().Atoi();
	iStack = ((TObjString*) tokens->At(2))->GetString().Atoi();
	iLink = 2 * ((TObjString*) tokens->At(3))->GetString().Atoi() + ((TObjString*) tokens->At(4))->GetString().Atoi();

	if (iEvent != iEventPrev || iStack != iStackPrev || iSec != iSecPrev) {
	    if(fTMU) {
		TList *ListOfTracks = new TList();
		fTMU->SetStack(iStackPrev);
		fTMU->SetSector(iSecPrev);
		fTMU->RunTMU(ListOfTracks);
		AliInfo(Form("--- There are %i tracks. Writing ...", ListOfTracks->GetEntries()));
		WriteTracksToTree(ListOfTracks);
		fTMU->WriteTrackletsToTree(fTrackletTree);
		WriteTracksToDataFile(ListOfTracks, iEventPrev);
		if (ListOfTracks->GetEntries() > 0) 
		    AliInfo(Form("   %d GeV/c", ((AliTRDtrackGTU*) ListOfTracks->At(0))->GetPt() ));
		delete fTMU;
		fTMU = new AliTRDgtuTMU(); 
		delete ListOfTracks;
		ListOfTracks = 0x0;
	    } else {
		fTMU = new AliTRDgtuTMU();
	    }
	    iStackPrev = iStack;
	    iSecPrev = iSec;
	    iEventPrev = iEvent;
	    evcnt++;
	    if (evcnt == noev)
		break;
	}
	for (Int_t i = 5; i < tokens->GetEntriesFast(); i++) {
	    UInt_t trackletWord = 0;
	    sscanf(((TObjString*) tokens->At(i))->GetString().Data(), "%x", &trackletWord);
	    if (trackletWord == 0x10001000) 
		break;
	    AliInfo(Form("%i. tracklet: %s -> 0x%08x", i-4, ((TObjString*) tokens->At(i))->GetString().Data(), trackletWord));
	    AliTRDtrackletWord *trkl = new AliTRDtrackletWord(trackletWord);
	    fTMU->AddTracklet(trkl, iLink);
	}
    }
    
    if (fTMU && evcnt < noev) {
	TList *ListOfTracks = new TList();
	fTMU->SetStack(iStackPrev);
	fTMU->SetSector(iSecPrev);
	fTMU->RunTMU(ListOfTracks);
	WriteTracksToTree(ListOfTracks);
	fTMU->WriteTrackletsToTree(fTrackletTree);
	WriteTracksToDataFile(ListOfTracks, iEventPrev);
	delete fTMU;
	delete ListOfTracks;
	fTMU = 0x0;
    }

    AliInfo(Form("Analyzed %i events", evcnt));
    return kTRUE; 
}

Bool_t AliTRDgtuSim::RunGTU(AliLoader *loader, AliESDEvent *esd) 
{
    if (!LoadTracklets(loader)) {
	AliError("Could not load the tracklets. Aborting ...");
	return kFALSE;
    }

    Int_t iStackPrev = -1;
    Int_t iSecPrev = -1;
    Int_t iSec = -1;
    Int_t iStack = -1;
    Int_t iLink = -1;

    if (fTMU) {
	delete fTMU;
	fTMU = 0x0;
    }
    
    TList *ListOfTracks = new TList();
    
    TIter next(fTrackletArray);
    AliTRDtrackletBase *trkl;

    while ((trkl = (AliTRDtrackletBase*) next())) {
	iSec = trkl->GetDetector() / 30;
	iStack = (trkl->GetDetector() % 30) / 6;
	iLink = 2 * (trkl->GetDetector() % 6) + (trkl->GetYbin() < 0 ? 0 : 1);

	if (iStack != iStackPrev || iSec != iSecPrev) {
	    if(fTMU) {
		fTMU->SetStack(iStackPrev);
		fTMU->SetSector(iSecPrev);
		fTMU->RunTMU(ListOfTracks);
		WriteTracksToTree(ListOfTracks);
		fTMU->WriteTrackletsToTree(fTrackletTree);
		WriteTracksToESD(ListOfTracks, esd);
		fTMU->Reset();
		ListOfTracks->Delete();
	    } else {
		fTMU = new AliTRDgtuTMU();
	    }
	    iStackPrev = iStack;
	    iSecPrev = iSec;
	}
	fTMU->AddTracklet(trkl, iLink);
    }
    
    if (fTMU) {
	fTMU->SetStack(iStackPrev);
	fTMU->SetSector(iSecPrev);
	fTMU->RunTMU(ListOfTracks);
	WriteTracksToTree(ListOfTracks);
	fTMU->WriteTrackletsToTree(fTrackletTree);
	WriteTracksToESD(ListOfTracks, esd);
	delete fTMU;
	fTMU = 0x0;
	ListOfTracks->Delete();
    }

    delete ListOfTracks;

    return kTRUE;
}

Bool_t AliTRDgtuSim::LoadTracklets(AliLoader *loader) 
{
  AliInfo("Loading tracklets ...");

  if (!loader) {
    AliError("No loader given!");
    return kFALSE;
  }

  AliDataLoader *trackletLoader = loader->GetDataLoader("tracklets");
  if (!trackletLoader) {
      AliError("No tracklet loader found!");
      return kFALSE;
  }

  trackletLoader->Load();
  
  TTree *trackletTree = trackletLoader->Tree();
  if (!trackletTree) {
    AliError("No tracklet tree found");
    return kFALSE;
  }  


  TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
  if (trklbranch) {
      if (!fTrackletArray)
	  fTrackletArray = new TClonesArray("AliTRDtrackletMCM", 1000);
      else if ((TClass::GetClass("AliTRDtrackletMCM"))->InheritsFrom(fTrackletArray->Class()))
	  fTrackletArray->Delete();
      else {
	  fTrackletArray->Delete();
	  delete fTrackletArray;
	  fTrackletArray = new TClonesArray("AliTRDtrackletMCM", 1000);
      }

      AliTRDtrackletMCM *trkl = new AliTRDtrackletMCM; 
      trklbranch->SetAddress(&trkl);
      for (Int_t iTracklet = 0; iTracklet < trklbranch->GetEntries(); iTracklet++) {
	  trklbranch->GetEntry(iTracklet);
	  new ((*fTrackletArray)[fTrackletArray->GetEntries()]) AliTRDtrackletMCM(*trkl);
      }
      return kTRUE;
  }

  trklbranch = trackletTree->GetBranch("trkbranch");

  if (!trklbranch) {
      AliError("Could not get trkbranch");
      return kFALSE;
  }
  
  if (!fTrackletArray)
      fTrackletArray = new TClonesArray("AliTRDtrackletWord", 1000);
  else if ((TClass::GetClass("AliTRDtrackletWord"))->InheritsFrom(fTrackletArray->Class()))
      fTrackletArray->Delete();
  else {
      fTrackletArray->Delete();
      delete fTrackletArray;
      fTrackletArray = new TClonesArray("AliTRDtrackletWord", 1000);
  }

  Int_t notrkl = 0;
  UInt_t *leaves = new UInt_t[258];
  AliInfo(Form("No. of entries: %i", trklbranch->GetEntries()));
  
  for (Int_t iEntry = 0; iEntry < trklbranch->GetEntries(); iEntry++) {
      trklbranch->SetAddress(leaves);
      trklbranch->GetEntry(iEntry);
      for (Int_t iTracklet = 0; iTracklet < 256; iTracklet++) {
	if (leaves[2 + iTracklet] == 0)
	  break;
	new((*fTrackletArray)[notrkl]) AliTRDtrackletWord(leaves[2 + iTracklet], leaves[0] + leaves[1]);
	notrkl++;
      }
      AliInfo(Form("Entry: %3i: Det: %3i, side: %i, 1st tracklet: 0x%08x, no: %i", iEntry, leaves[0], leaves[1], leaves[2], notrkl));
  }

  return kTRUE;
}

Bool_t AliTRDgtuSim::WriteTracksToDataFile(TList *ListOfTracks, Int_t event) 
{
    Int_t sm = 0;
    Int_t stack = 0;

    FILE *out;
    out = fopen("test.data", "a");

    AliInfo(Form("%i tracks found in event %i", ListOfTracks->GetSize(), event));
    fprintf(out, "0 %5i %2i %i  00000000\n", event, sm, stack);
    for (Int_t i = 0; i < ListOfTracks->GetSize(); i++) {
	AliTRDtrackGTU *trk = (AliTRDtrackGTU*) ListOfTracks->At(i);
	sm = trk->GetSector();
	stack = trk->GetStack();
	fprintf(out, "1 %5i %2i %2i %3i %3i %3i %3i %3i %3i %3i %4i %f\n", event, sm, stack, trk->GetTrackletMask(), 
	       trk->GetTrackletIndex(5), 
	       trk->GetTrackletIndex(4), 
	       trk->GetTrackletIndex(3), 
	       trk->GetTrackletIndex(2), 
	       trk->GetTrackletIndex(1), 
	       trk->GetTrackletIndex(0),
	       trk->GetPtInt(), 
	       trk->GetPt());
    }
    fclose(out);
    return kTRUE;
}

Bool_t AliTRDgtuSim::WriteTracksToTree(TList *ListOfTracks, Int_t /*event*/) 
{
  AliInfo(Form("Writing %i tracks to the tree...", ListOfTracks->GetEntries()));

  if (!ListOfTracks)
    return kFALSE;

  if (ListOfTracks->GetEntries() <= 0) 
    return kTRUE;

  if (!fTrackTree)
    fTrackTree = new TTree("gtutracks", "GTU tracks");

  AliTRDtrackGTU *trk = 0x0;
  TBranch *branch = fTrackTree->GetBranch("TRDgtuTrack");
  if (!branch) {
      branch = fTrackTree->Branch("TRDgtuTrack", "AliTRDtrackGTU", &trk, 32000, 99);
  }

  TIter next(ListOfTracks);
  while ((trk = (AliTRDtrackGTU*) next())) {
      trk->CookLabel();
      branch->SetAddress(&trk);
      fTrackTree->Fill();   
  }
  fTrackTree->ResetBranchAddress(branch);

  return kTRUE; 
}

Bool_t AliTRDgtuSim::WriteTreesToFile() {
  TFile *f = TFile::Open("TRD.GtuTracking.root", "RECREATE");
  f->cd();
  if (fTrackTree)
    f->WriteTObject(fTrackTree);
  if (fTrackletTree)
    f->WriteTObject(fTrackletTree);
  f->Close();
  return kTRUE;
}

Bool_t AliTRDgtuSim::WriteTracksToESD(TList *ListOfTracks, AliESDEvent *esd) 
{
    if (esd) {
	TIter next(ListOfTracks);
	while (AliTRDtrackGTU *trk = (AliTRDtrackGTU*) next()) {
	    AliESDTrdTrack *trdtrack = trk->CreateTrdTrack();
	    esd->AddTrdTrack(trdtrack);
	    delete trdtrack;
	}
    }
    return kTRUE;
}
Commit	Line	Data
52c19022	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
4cc89512	185	while ((trkl = (AliTRDtrackletBase*) next())) {
52c19022	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);
4cc89512	355	while ((trk = (AliTRDtrackGTU*) next())) {
4cc89512	356	trk->CookLabel();
52c19022	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	}