[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 "TObject.h"
#include "TClonesArray.h"

#include "AliRun.h"
#include "AliRunLoader.h"
#include "AliLoader.h"
#include "AliTreeLoader.h"
#include "AliLog.h"
#include "AliESDTrdTrack.h"
#include "AliESDTrdTracklet.h"

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

ClassImp(AliTRDgtuSim)

AliTRDgtuSim::AliTRDgtuSim(AliRunLoader *rl)
  : TObject(),
  fRunLoader(rl),
  fFeeParam(AliTRDfeeParam::Instance()),
  fTMU(0x0),
  fTrackletArray(0x0)
{

}

AliTRDgtuSim::~AliTRDgtuSim()
{
  // destructor

  if (fTrackletArray)
    fTrackletArray->Clear();
  delete fTrackletArray;
}

Bool_t AliTRDgtuSim::RunGTUFromTrackletFile(TString filename, Int_t event, Int_t noev)
{
  // run the GTU from a file of tracklets
  // used for comparison to VHDL simulation

  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;

  TClonesArray trklArray("AliTRDtrackletWord", 100);
  TClonesArray trklArrayGTU("AliTRDtrackletGTU", 100);

  AliDebug(1, Form("--------- Reading from %s ----------", filename.Data()));
  while (getline(input, str)) {
    lineno++;
    string = str;

    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);
	AliDebug(1,Form("--- There are %i tracks. Writing ...", listOfTracks->GetEntries()));
	WriteTracksToDataFile(listOfTracks, iEventPrev);
	if (listOfTracks->GetEntries() > 0)
	  AliDebug(2,Form("   %4.1f 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(), "%i", &trackletWord);
      if (trackletWord == 0x10001000)
	break;
      AliDebug(2, Form("link: %2i trkl: %2i - %s -> 0x%08x",
		       iLink, i-4, ((TObjString*) tokens->At(i))->GetString().Data(), trackletWord));
      AliTRDtrackletWord *tracklet = new (trklArray[trklArray.GetEntriesFast()])       AliTRDtrackletWord(trackletWord);
      AliTRDtrackletGTU   *trkl    = new (trklArrayGTU[trklArrayGTU.GetEntriesFast()]) AliTRDtrackletGTU(tracklet);
      if (fTMU)
	fTMU->AddTracklet(trkl, iLink);
    }
  }

  if (fTMU && evcnt < noev) {
    TList *listOfTracks = new TList();
    fTMU->SetStack(iStackPrev);
    fTMU->SetSector(iSecPrev);
    fTMU->RunTMU(listOfTracks);
    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)
{
  // run the GTU on tracklets taken from the loader
  // if specified the GTU tracks are written to the ESD event

  if (!fFeeParam->GetTracklet())
    return kFALSE;

  if (fTrackletArray)
    fTrackletArray->Clear();

  if (loader) {
    if (!LoadTracklets(loader)) {
	AliError("Could not load the tracklets. Nothing done ...");
	return kFALSE;
    }
  }
  else {
    LoadTracklets(esd);
  }

    AliDebug(1, Form("running on %i tracklets", fTrackletArray->GetEntriesFast()));

    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);

    while (AliTRDtrackletGTU *trkl = (AliTRDtrackletGTU*) next()) {
	iSec = trkl->GetDetector() / 30;
	iStack = (trkl->GetDetector() % 30) / 6;
	iLink = trkl->GetHCId() % 12;

	if (iStack != iStackPrev || iSec != iSecPrev) {
	    if(fTMU) {
		fTMU->SetStack(iStackPrev);
		fTMU->SetSector(iSecPrev);
		fTMU->RunTMU(listOfTracks);
		WriteTracksToLoader(listOfTracks);
		WriteTracksToESD(listOfTracks, esd);
		fTMU->Reset();
		listOfTracks->Delete();
	    } else {
		fTMU = new AliTRDgtuTMU();
	    }
	    iStackPrev = iStack;
	    iSecPrev = iSec;
	    AliDebug(1, Form("now in sec %i, stack %i", iSec, iStack));
	}
	AliDebug(1, Form("adding tracklet: 0x%08x in sec %i stack %i link %i",
			 trkl->GetTrackletWord(), trkl->GetDetector() / 30, (trkl->GetDetector() % 30) / 6, trkl->GetHCId() % 12));
	if (fTMU) {
	  fTMU->AddTracklet(trkl, iLink);
	}
    }

    if (fTMU) {
	fTMU->SetStack(iStackPrev);
	fTMU->SetSector(iSecPrev);
	fTMU->RunTMU(listOfTracks);
	WriteTracksToLoader(listOfTracks);
	WriteTracksToESD(listOfTracks, esd);
	delete fTMU;
	fTMU = 0x0;
	listOfTracks->Delete();
    }

    delete listOfTracks;

    return kTRUE;
}

Bool_t AliTRDgtuSim::LoadTracklets(const AliESDEvent *const esd)
{
  AliDebug(1,"Loading tracklets from ESD event ...");

  if (!fTrackletArray)
    fTrackletArray = new TClonesArray("AliTRDtrackletGTU", 1000);

  for (Int_t iTracklet = 0; iTracklet < esd->GetNumberOfTrdTracklets(); iTracklet++) {
    AliESDTrdTracklet *trkl = esd->GetTrdTracklet(iTracklet);
    new ((*fTrackletArray)[fTrackletArray->GetEntries()]) AliTRDtrackletGTU(trkl);
  }

  return kTRUE;
}

Bool_t AliTRDgtuSim::LoadTracklets(AliLoader *const loader)
{
  // load the tracklets using the given loader

  AliDebug(1,"Loading tracklets ...");

  if (!fFeeParam->GetTracklet())
    return kFALSE;

  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 = 0x0;

  // simulated tracklets
  trackletTree = trackletLoader->Tree();
  if (trackletTree) {
    TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
    if (trklbranch) {
      if (!fTrackletArray)
	fTrackletArray = new TClonesArray("AliTRDtrackletGTU", 1000);

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

  // raw tracklets
  AliTreeLoader *tl = (AliTreeLoader*) trackletLoader->GetBaseLoader("tracklets-raw");
  trackletTree = tl ? tl->Load(), tl->Tree() : 0x0;

  if (trackletTree) {
    if (!fTrackletArray)
      fTrackletArray = new TClonesArray("AliTRDtrackletGTU", 1000);

    Int_t hc;
    TClonesArray *ar = 0x0;
    trackletTree->SetBranchAddress("hc", &hc);
    trackletTree->SetBranchAddress("trkl", &ar);

    for (Int_t iEntry = 0; iEntry < trackletTree->GetEntries(); iEntry++) {
      trackletTree->GetEntry(iEntry);
      AliDebug(2, Form("%i tracklets in HC %i", ar->GetEntriesFast(), hc));
      for (Int_t iTracklet = 0; iTracklet < ar->GetEntriesFast(); iTracklet++) {
	AliTRDtrackletWord *trklWord = (AliTRDtrackletWord*) (*ar)[iTracklet];
	new((*fTrackletArray)[fTrackletArray->GetEntriesFast()]) AliTRDtrackletGTU(new AliTRDtrackletWord(trklWord->GetTrackletWord(), hc));
      }
    }
    return kTRUE;
  }

  AliError("No raw tracklet tree found\n");

  return kFALSE;
}

Bool_t AliTRDgtuSim::WriteTracksToDataFile(TList *listOfTracks, Int_t event)
{
  // write the found tracks to a data file
  // used for comparison to VHDL simulation

    Int_t sm = 0;
    Int_t stack = 0;

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

    AliDebug(1,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();

	ULong64_t trackWord = 1;
	AppendBits(trackWord,   1, 0);
	AppendBits(trackWord,   6, trk->GetTrackletMask());
	AppendBits(trackWord,  18, (Int_t) trk->GetA());
	AppendBits(trackWord,  18, (Int_t) trk->GetB());
	AppendBits(trackWord,  12, (Int_t) trk->GetC());
	AppendBits(trackWord,   8, trk->GetPID());
	fprintf(out, "ev. %i sec. %i stack %i - track word: 0x%016llx, ",
		event, sm, stack, trackWord);

	trackWord = 0;
	AppendBits(trackWord, 11, 0); // flags
	AppendBits(trackWord,  3, 0);
	AppendBits(trackWord, 13, trk->GetYapprox());
	AppendBits(trackWord,  6, trk->GetTrackletIndex(5));
	AppendBits(trackWord,  6, trk->GetTrackletIndex(4));
	AppendBits(trackWord,  6, trk->GetTrackletIndex(3));
	AppendBits(trackWord,  6, trk->GetTrackletIndex(2));
	AppendBits(trackWord,  6, trk->GetTrackletIndex(1));
	AppendBits(trackWord,  6, trk->GetTrackletIndex(0));
	fprintf(out, "extended track word: 0x%016llx\n", trackWord);

	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::WriteTracksToESD(const TList * const listOfTracks, AliESDEvent *esd)
{
  // fill the found tracks to the given ESD event

    if (esd) {
	TIter next(listOfTracks);
	while (AliTRDtrackGTU *trk = (AliTRDtrackGTU*) next()) {
	    AliESDTrdTrack *trdtrack = trk->CreateTrdTrack();
	    if (trdtrack->GetLabel() < 0)
	      trdtrack->SetLabel(-2);
	    esd->AddTrdTrack(trdtrack);
	    delete trdtrack;
	}
    }
    return kTRUE;
}

Bool_t AliTRDgtuSim::WriteTracksToLoader(const TList * const listOfTracks)
{
  // write the GTU tracks to the dedicated loader
  // these tracks contain more information than the ones in the ESD

  AliRunLoader *rl = AliRunLoader::Instance();
  AliDataLoader *dl = 0x0;
  if (rl)
    dl = rl->GetLoader("TRDLoader")->GetDataLoader("gtutracks");
  if (!dl) {
    AliError("Could not get the GTU-track data loader!");
    return kFALSE;
  }

  TTree *trackTree = dl->Tree();
  if (!trackTree) {
    dl->MakeTree();
    trackTree = dl->Tree();
  }

  AliTRDtrackGTU *trk = 0x0;

  if (!trackTree->GetBranch("TRDtrackGTU"))
    trackTree->Branch("TRDtrackGTU", "AliTRDtrackGTU", &trk, 32000);

  AliDebug(1, Form("Writing %i tracks to loader", listOfTracks->GetEntries()));
  TIter next(listOfTracks);
  while ((trk = (AliTRDtrackGTU*) next())) {
    trackTree->SetBranchAddress("TRDtrackGTU", &trk);
    trackTree->Fill();
  }

  dl->WriteData("OVERWRITE");

  return kTRUE;
}
Commit	Line	Data
	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	}
	305	return kTRUE;
	306	}
	307	}
	308
	309	// raw tracklets
	310	AliTreeLoader tl = (AliTreeLoader) trackletLoader->GetBaseLoader("tracklets-raw");
	311	trackletTree = tl ? tl->Load(), tl->Tree() : 0x0;
	312
	313	if (trackletTree) {
	314	if (!fTrackletArray)
	315	fTrackletArray = new TClonesArray("AliTRDtrackletGTU", 1000);
	316
	317	Int_t hc;
	318	TClonesArray *ar = 0x0;
	319	trackletTree->SetBranchAddress("hc", &hc);
	320	trackletTree->SetBranchAddress("trkl", &ar);
	321
	322	for (Int_t iEntry = 0; iEntry < trackletTree->GetEntries(); iEntry++) {
	323	trackletTree->GetEntry(iEntry);
	324	AliDebug(2, Form("%i tracklets in HC %i", ar->GetEntriesFast(), hc));
	325	for (Int_t iTracklet = 0; iTracklet < ar->GetEntriesFast(); iTracklet++) {
	326	AliTRDtrackletWord trklWord = (AliTRDtrackletWord) (*ar)[iTracklet];
	327	new((*fTrackletArray)[fTrackletArray->GetEntriesFast()]) AliTRDtrackletGTU(new AliTRDtrackletWord(trklWord->GetTrackletWord(), hc));
	328	}
	329	}
	330	return kTRUE;
	331	}
	332
	333	AliError("No raw tracklet tree found\n");
	334
	335	return kFALSE;
	336	}
	337
	338	Bool_t AliTRDgtuSim::WriteTracksToDataFile(TList *listOfTracks, Int_t event)
	339	{
	340	// write the found tracks to a data file
	341	// used for comparison to VHDL simulation
	342
	343	Int_t sm = 0;
	344	Int_t stack = 0;
	345
	346	FILE *out;
	347	out = fopen("test.data", "a");
	348
	349	AliDebug(1,Form("%i tracks found in event %i", listOfTracks->GetSize(), event));
	350	// fprintf(out, "0 %5i %2i %i 00000000\n", event, sm, stack);
	351	for (Int_t i = 0; i < listOfTracks->GetSize(); i++) {
	352	AliTRDtrackGTU trk = (AliTRDtrackGTU) listOfTracks->At(i);
	353	sm = trk->GetSector();
	354	stack = trk->GetStack();
	355
	356	ULong64_t trackWord = 1;
	357	AppendBits(trackWord, 1, 0);
	358	AppendBits(trackWord, 6, trk->GetTrackletMask());
	359	AppendBits(trackWord, 18, (Int_t) trk->GetA());
	360	AppendBits(trackWord, 18, (Int_t) trk->GetB());
	361	AppendBits(trackWord, 12, (Int_t) trk->GetC());
	362	AppendBits(trackWord, 8, trk->GetPID());
	363	fprintf(out, "ev. %i sec. %i stack %i - track word: 0x%016llx, ",
	364	event, sm, stack, trackWord);
	365
	366	trackWord = 0;
	367	AppendBits(trackWord, 11, 0); // flags
	368	AppendBits(trackWord, 3, 0);
	369	AppendBits(trackWord, 13, trk->GetYapprox());
	370	AppendBits(trackWord, 6, trk->GetTrackletIndex(5));
	371	AppendBits(trackWord, 6, trk->GetTrackletIndex(4));
	372	AppendBits(trackWord, 6, trk->GetTrackletIndex(3));
	373	AppendBits(trackWord, 6, trk->GetTrackletIndex(2));
	374	AppendBits(trackWord, 6, trk->GetTrackletIndex(1));
	375	AppendBits(trackWord, 6, trk->GetTrackletIndex(0));
	376	fprintf(out, "extended track word: 0x%016llx\n", trackWord);
	377
	378	fprintf(out, "1 %5i %2i %2i %3i %3i %3i %3i %3i %3i %3i %4i %f\n", event, sm, stack, trk->GetTrackletMask(),
	379	trk->GetTrackletIndex(5),
	380	trk->GetTrackletIndex(4),
	381	trk->GetTrackletIndex(3),
	382	trk->GetTrackletIndex(2),
	383	trk->GetTrackletIndex(1),
	384	trk->GetTrackletIndex(0),
	385	trk->GetPtInt(),
	386	trk->GetPt());
	387	}
	388	fclose(out);
	389	return kTRUE;
	390	}
	391
	392	Bool_t AliTRDgtuSim::WriteTracksToESD(const TList * const listOfTracks, AliESDEvent *esd)
	393	{
	394	// fill the found tracks to the given ESD event
	395
	396	if (esd) {
	397	TIter next(listOfTracks);
	398	while (AliTRDtrackGTU trk = (AliTRDtrackGTU) next()) {
	399	AliESDTrdTrack *trdtrack = trk->CreateTrdTrack();
	400	if (trdtrack->GetLabel() < 0)
	401	trdtrack->SetLabel(-2);
	402	esd->AddTrdTrack(trdtrack);
	403	delete trdtrack;
	404	}
	405	}
	406	return kTRUE;
	407	}
	408
	409	Bool_t AliTRDgtuSim::WriteTracksToLoader(const TList * const listOfTracks)
	410	{
	411	// write the GTU tracks to the dedicated loader
	412	// these tracks contain more information than the ones in the ESD
	413
	414	AliRunLoader *rl = AliRunLoader::Instance();
	415	AliDataLoader *dl = 0x0;
	416	if (rl)
	417	dl = rl->GetLoader("TRDLoader")->GetDataLoader("gtutracks");
	418	if (!dl) {
	419	AliError("Could not get the GTU-track data loader!");
	420	return kFALSE;
	421	}
	422
	423	TTree *trackTree = dl->Tree();
	424	if (!trackTree) {
	425	dl->MakeTree();
	426	trackTree = dl->Tree();
	427	}
	428
	429	AliTRDtrackGTU *trk = 0x0;
	430
	431	if (!trackTree->GetBranch("TRDtrackGTU"))
	432	trackTree->Branch("TRDtrackGTU", "AliTRDtrackGTU", &trk, 32000);
	433
	434	AliDebug(1, Form("Writing %i tracks to loader", listOfTracks->GetEntries()));
	435	TIter next(listOfTracks);
	436	while ((trk = (AliTRDtrackGTU*) next())) {
	437	trackTree->SetBranchAddress("TRDtrackGTU", &trk);
	438	trackTree->Fill();
	439	}
	440
	441	dl->WriteData("OVERWRITE");
	442
	443	return kTRUE;
	444	}