[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 "AliRun.h"
#include "AliRunLoader.h"
#include "AliLoader.h"
#include "AliLog.h"
#include "AliESDTrdTrack.h"

#include "AliTRDgtuSim.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),
  fTMU(0x0),
  fTrackletArray(0x0),
  fTrackTree(0x0),
  fTrackletTree(0x0)
{
  fTrackletTree = new TTree("gtutracklets", "Tree with GTU tracklets");
  fTrackletTree->SetDirectory(0);
}

AliTRDgtuSim::~AliTRDgtuSim() 
{
  // destructor

  if (fTrackletArray)
    fTrackletArray->Delete();
  delete fTrackletArray;
  delete fTrackletTree;
}

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

    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;
    
    AliDebug(5,"--------- Reading from file ----------");
    while (getline(input, str)) {
	lineno++;
	string = str;
	AliDebug(5,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);
		AliDebug(1,Form("--- There are %i tracks. Writing ...", listOfTracks->GetEntries()));
		WriteTracksToTree(listOfTracks);
		fTMU->WriteTrackletsToTree(fTrackletTree);
		WriteTracksToDataFile(listOfTracks, iEventPrev);
		if (listOfTracks->GetEntries() > 0) 
		    AliDebug(2,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;
	    AliDebug(2,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) 
{
  // run the GTU on tracklets taken from the loader
  // if specified the GTU tracks are written to the ESD event 

    if (!LoadTracklets(loader)) {
	AliError("Could not load the tracklets. Nothing done ...");
	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 *const loader) 
{
  // load the tracklets using the given loader

  AliDebug(1,"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];
  AliDebug(1,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], 2*leaves[0] + leaves[1]);
	notrkl++;
      }
      AliDebug(2,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) 
{
  // 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();
	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*/) 
{
  // write the tracks to the tree for intermediate storage

  AliDebug(1,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");
    fTrackTree->SetDirectory(0);
  }

  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() const {
  // write the trees holding tracklets and tracks to file

  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(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();
	    esd->AddTrdTrack(trdtrack);
	    delete trdtrack;
	}
    }
    return kTRUE;
}

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

  if (!fTrackTree) {
    AliError("No track tree found!");
    return kFALSE;
  }

  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;
  TBranch *trkbranch = trackTree->GetBranch("TRDtrackGTU");
  if (!trkbranch)
    trkbranch = trackTree->Branch("TRDtrackGTU", "AliTRDtrackGTU", &trk, 32000);
  
  TBranch *branch = fTrackTree->GetBranch("TRDgtuTrack");
  if (!branch)
    return kFALSE;

  AliDebug(1,Form("Found %i tracks", branch->GetEntries()));

  for (Int_t iTrack = 0; iTrack < branch->GetEntries(); iTrack++) {
    branch->SetAddress(&trk);
    branch->GetEntry(iTrack);
    trkbranch->SetAddress(&trk);
    trackTree->Fill();
  }

  dl->WriteData("OVERWRITE");

  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
4d6aee34	34	#include "AliRun.h"
	35	#include "AliRunLoader.h"
	36	#include "AliLoader.h"
	37	#include "AliLog.h"
	38	#include "AliESDTrdTrack.h"
	39
52c19022	40	#include "AliTRDgtuSim.h"
52c19022	41	#include "AliTRDgtuTMU.h"
	42	#include "AliTRDtrackGTU.h"
	43	#include "AliTRDtrackletWord.h"
	44	#include "AliTRDtrackletMCM.h"
	45	#include "AliESDEvent.h"
52c19022	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");
80f93426	58	fTrackletTree->SetDirectory(0);
52c19022	59	}
	60
	61	AliTRDgtuSim::~AliTRDgtuSim()
	62	{
36dc3337	63	// destructor
36dc3337	64
52c19022	65	if (fTrackletArray)
	66	fTrackletArray->Delete();
	67	delete fTrackletArray;
	68	delete fTrackletTree;
	69	}
	70
	71	Bool_t AliTRDgtuSim::RunGTUFromTrackletFile(TString filename, Int_t event, Int_t noev)
	72	{
36dc3337	73	// run the GTU from a file of tracklets
	74	// used for comparison to VHDL simulation
	75
52c19022	76	AliInfo(Form("Running the GTU simulation on file: %s", filename.Data()));
	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
c8b1590d	94	AliDebug(5,"--------- Reading from file ----------");
52c19022	95	while (getline(input, str)) {
	96	lineno++;
	97	string = str;
c8b1590d	98	AliDebug(5,Form("Line %i : %s", lineno, string.Data()));
52c19022	99
	100	TObjArray *tokens = string.Tokenize(" ");
	101	if (tokens->GetEntriesFast() < 7) {
	102	AliWarning(Form("Invalid input in line %i, too few parameters", lineno));
	103	continue;
	104	}
	105
	106	if ( ((TObjString*) tokens->At(0))->GetString().Atoi() < event)
	107	continue;
	108
	109	iEvent = ((TObjString*) tokens->At(0))->GetString().Atoi();
	110	iSec = ((TObjString*) tokens->At(1))->GetString().Atoi();
	111	iStack = ((TObjString*) tokens->At(2))->GetString().Atoi();
	112	iLink = 2 * ((TObjString) tokens->At(3))->GetString().Atoi() + ((TObjString) tokens->At(4))->GetString().Atoi();
	113
	114	if (iEvent != iEventPrev \|\| iStack != iStackPrev \|\| iSec != iSecPrev) {
	115	if(fTMU) {
36dc3337	116	TList *listOfTracks = new TList();
52c19022	117	fTMU->SetStack(iStackPrev);
52c19022	118	fTMU->SetSector(iSecPrev);
36dc3337	119	fTMU->RunTMU(listOfTracks);
	120	AliDebug(1,Form("--- There are %i tracks. Writing ...", listOfTracks->GetEntries()));
	121	WriteTracksToTree(listOfTracks);
52c19022	122	fTMU->WriteTrackletsToTree(fTrackletTree);
36dc3337	123	WriteTracksToDataFile(listOfTracks, iEventPrev);
	124	if (listOfTracks->GetEntries() > 0)
	125	AliDebug(2,Form(" %d GeV/c", ((AliTRDtrackGTU*) listOfTracks->At(0))->GetPt() ));
52c19022	126	delete fTMU;
52c19022	127	fTMU = new AliTRDgtuTMU();
36dc3337	128	delete listOfTracks;
36dc3337	129	listOfTracks = 0x0;
52c19022	130	} else {
	131	fTMU = new AliTRDgtuTMU();
	132	}
	133	iStackPrev = iStack;
	134	iSecPrev = iSec;
	135	iEventPrev = iEvent;
	136	evcnt++;
	137	if (evcnt == noev)
	138	break;
	139	}
	140	for (Int_t i = 5; i < tokens->GetEntriesFast(); i++) {
	141	UInt_t trackletWord = 0;
	142	sscanf(((TObjString*) tokens->At(i))->GetString().Data(), "%x", &trackletWord);
	143	if (trackletWord == 0x10001000)
	144	break;
c8b1590d	145	AliDebug(2,Form("%i. tracklet: %s -> 0x%08x", i-4, ((TObjString*) tokens->At(i))->GetString().Data(), trackletWord));
52c19022	146	AliTRDtrackletWord *trkl = new AliTRDtrackletWord(trackletWord);
	147	fTMU->AddTracklet(trkl, iLink);
	148	}
	149	}
	150
	151	if (fTMU && evcnt < noev) {
36dc3337	152	TList *listOfTracks = new TList();
52c19022	153	fTMU->SetStack(iStackPrev);
52c19022	154	fTMU->SetSector(iSecPrev);
36dc3337	155	fTMU->RunTMU(listOfTracks);
36dc3337	156	WriteTracksToTree(listOfTracks);
52c19022	157	fTMU->WriteTrackletsToTree(fTrackletTree);
36dc3337	158	WriteTracksToDataFile(listOfTracks, iEventPrev);
52c19022	159	delete fTMU;
36dc3337	160	delete listOfTracks;
52c19022	161	fTMU = 0x0;
	162	}
	163
	164	AliInfo(Form("Analyzed %i events", evcnt));
	165	return kTRUE;
	166	}
	167
	168	Bool_t AliTRDgtuSim::RunGTU(AliLoader loader, AliESDEvent esd)
	169	{
36dc3337	170	// run the GTU on tracklets taken from the loader
	171	// if specified the GTU tracks are written to the ESD event
	172
52c19022	173	if (!LoadTracklets(loader)) {
a8518fd2	174	AliError("Could not load the tracklets. Nothing done ...");
52c19022	175	return kFALSE;
	176	}
	177
	178	Int_t iStackPrev = -1;
	179	Int_t iSecPrev = -1;
	180	Int_t iSec = -1;
	181	Int_t iStack = -1;
	182	Int_t iLink = -1;
	183
	184	if (fTMU) {
	185	delete fTMU;
	186	fTMU = 0x0;
	187	}
	188
36dc3337	189	TList *listOfTracks = new TList();
52c19022	190
	191	TIter next(fTrackletArray);
	192	AliTRDtrackletBase *trkl;
	193
4cc89512	194	while ((trkl = (AliTRDtrackletBase*) next())) {
52c19022	195	iSec = trkl->GetDetector() / 30;
	196	iStack = (trkl->GetDetector() % 30) / 6;
	197	iLink = 2 * (trkl->GetDetector() % 6) + (trkl->GetYbin() < 0 ? 0 : 1);
	198
	199	if (iStack != iStackPrev \|\| iSec != iSecPrev) {
	200	if(fTMU) {
	201	fTMU->SetStack(iStackPrev);
	202	fTMU->SetSector(iSecPrev);
36dc3337	203	fTMU->RunTMU(listOfTracks);
36dc3337	204	WriteTracksToTree(listOfTracks);
52c19022	205	fTMU->WriteTrackletsToTree(fTrackletTree);
36dc3337	206	WriteTracksToESD(listOfTracks, esd);
52c19022	207	fTMU->Reset();
36dc3337	208	listOfTracks->Delete();
52c19022	209	} else {
	210	fTMU = new AliTRDgtuTMU();
	211	}
	212	iStackPrev = iStack;
	213	iSecPrev = iSec;
	214	}
	215	fTMU->AddTracklet(trkl, iLink);
	216	}
	217
	218	if (fTMU) {
	219	fTMU->SetStack(iStackPrev);
	220	fTMU->SetSector(iSecPrev);
36dc3337	221	fTMU->RunTMU(listOfTracks);
36dc3337	222	WriteTracksToTree(listOfTracks);
52c19022	223	fTMU->WriteTrackletsToTree(fTrackletTree);
36dc3337	224	WriteTracksToESD(listOfTracks, esd);
52c19022	225	delete fTMU;
52c19022	226	fTMU = 0x0;
36dc3337	227	listOfTracks->Delete();
52c19022	228	}
52c19022	229
36dc3337	230	delete listOfTracks;
52c19022	231
	232	return kTRUE;
	233	}
	234
36dc3337	235	Bool_t AliTRDgtuSim::LoadTracklets(AliLoader *const loader)
52c19022	236	{
36dc3337	237	// load the tracklets using the given loader
36dc3337	238
c8b1590d	239	AliDebug(1,"Loading tracklets ...");
52c19022	240
	241	if (!loader) {
	242	AliError("No loader given!");
	243	return kFALSE;
	244	}
	245
	246	AliDataLoader *trackletLoader = loader->GetDataLoader("tracklets");
	247	if (!trackletLoader) {
	248	AliError("No tracklet loader found!");
	249	return kFALSE;
	250	}
	251
	252	trackletLoader->Load();
	253
	254	TTree *trackletTree = trackletLoader->Tree();
	255	if (!trackletTree) {
	256	AliError("No tracklet tree found");
	257	return kFALSE;
	258	}
	259
	260
	261	TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
	262	if (trklbranch) {
	263	if (!fTrackletArray)
	264	fTrackletArray = new TClonesArray("AliTRDtrackletMCM", 1000);
	265	else if ((TClass::GetClass("AliTRDtrackletMCM"))->InheritsFrom(fTrackletArray->Class()))
	266	fTrackletArray->Delete();
	267	else {
	268	fTrackletArray->Delete();
	269	delete fTrackletArray;
	270	fTrackletArray = new TClonesArray("AliTRDtrackletMCM", 1000);
	271	}
	272
	273	AliTRDtrackletMCM *trkl = new AliTRDtrackletMCM;
	274	trklbranch->SetAddress(&trkl);
	275	for (Int_t iTracklet = 0; iTracklet < trklbranch->GetEntries(); iTracklet++) {
	276	trklbranch->GetEntry(iTracklet);
	277	new ((fTrackletArray)[fTrackletArray->GetEntries()]) AliTRDtrackletMCM(trkl);
	278	}
	279	return kTRUE;
	280	}
	281
	282	trklbranch = trackletTree->GetBranch("trkbranch");
	283
	284	if (!trklbranch) {
	285	AliError("Could not get trkbranch");
	286	return kFALSE;
	287	}
	288
	289	if (!fTrackletArray)
	290	fTrackletArray = new TClonesArray("AliTRDtrackletWord", 1000);
	291	else if ((TClass::GetClass("AliTRDtrackletWord"))->InheritsFrom(fTrackletArray->Class()))
	292	fTrackletArray->Delete();
	293	else {
	294	fTrackletArray->Delete();
	295	delete fTrackletArray;
	296	fTrackletArray = new TClonesArray("AliTRDtrackletWord", 1000);
	297	}
	298
	299	Int_t notrkl = 0;
	300	UInt_t *leaves = new UInt_t[258];
c8b1590d	301	AliDebug(1,Form("No. of entries: %i", trklbranch->GetEntries()));
52c19022	302
	303	for (Int_t iEntry = 0; iEntry < trklbranch->GetEntries(); iEntry++) {
	304	trklbranch->SetAddress(leaves);
	305	trklbranch->GetEntry(iEntry);
	306	for (Int_t iTracklet = 0; iTracklet < 256; iTracklet++) {
	307	if (leaves[2 + iTracklet] == 0)
	308	break;
4ff7ed2b	309	new((fTrackletArray)[notrkl]) AliTRDtrackletWord(leaves[2 + iTracklet], 2leaves[0] + leaves[1]);
52c19022	310	notrkl++;
52c19022	311	}
c8b1590d	312	AliDebug(2,Form("Entry: %3i: Det: %3i, side: %i, 1st tracklet: 0x%08x, no: %i", iEntry, leaves[0], leaves[1], leaves[2], notrkl));
52c19022	313	}
	314
	315	return kTRUE;
	316	}
	317
36dc3337	318	Bool_t AliTRDgtuSim::WriteTracksToDataFile(TList *listOfTracks, Int_t event)
52c19022	319	{
36dc3337	320	// write the found tracks to a data file
	321	// used for comparison to VHDL simulation
	322
52c19022	323	Int_t sm = 0;
	324	Int_t stack = 0;
	325
	326	FILE *out;
	327	out = fopen("test.data", "a");
	328
36dc3337	329	AliDebug(1,Form("%i tracks found in event %i", listOfTracks->GetSize(), event));
52c19022	330	fprintf(out, "0 %5i %2i %i 00000000\n", event, sm, stack);
36dc3337	331	for (Int_t i = 0; i < listOfTracks->GetSize(); i++) {
36dc3337	332	AliTRDtrackGTU trk = (AliTRDtrackGTU) listOfTracks->At(i);
52c19022	333	sm = trk->GetSector();
	334	stack = trk->GetStack();
	335	fprintf(out, "1 %5i %2i %2i %3i %3i %3i %3i %3i %3i %3i %4i %f\n", event, sm, stack, trk->GetTrackletMask(),
	336	trk->GetTrackletIndex(5),
	337	trk->GetTrackletIndex(4),
	338	trk->GetTrackletIndex(3),
	339	trk->GetTrackletIndex(2),
	340	trk->GetTrackletIndex(1),
	341	trk->GetTrackletIndex(0),
	342	trk->GetPtInt(),
	343	trk->GetPt());
	344	}
	345	fclose(out);
	346	return kTRUE;
	347	}
	348
36dc3337	349	Bool_t AliTRDgtuSim::WriteTracksToTree(TList listOfTracks, Int_t /event*/)
52c19022	350	{
36dc3337	351	// write the tracks to the tree for intermediate storage
52c19022	352
36dc3337	353	AliDebug(1,Form("Writing %i tracks to the tree...", listOfTracks->GetEntries()));
	354
	355	if (!listOfTracks)
52c19022	356	return kFALSE;
52c19022	357
36dc3337	358	if (listOfTracks->GetEntries() <= 0)
52c19022	359	return kTRUE;
52c19022	360
80f93426	361	if (!fTrackTree) {
52c19022	362	fTrackTree = new TTree("gtutracks", "GTU tracks");
80f93426	363	fTrackTree->SetDirectory(0);
80f93426	364	}
52c19022	365
	366	AliTRDtrackGTU *trk = 0x0;
	367	TBranch *branch = fTrackTree->GetBranch("TRDgtuTrack");
	368	if (!branch) {
	369	branch = fTrackTree->Branch("TRDgtuTrack", "AliTRDtrackGTU", &trk, 32000, 99);
	370	}
	371
36dc3337	372	TIter next(listOfTracks);
4cc89512	373	while ((trk = (AliTRDtrackGTU*) next())) {
4cc89512	374	trk->CookLabel();
52c19022	375	branch->SetAddress(&trk);
	376	fTrackTree->Fill();
	377	}
	378	fTrackTree->ResetBranchAddress(branch);
	379
	380	return kTRUE;
	381	}
	382
36dc3337	383	Bool_t AliTRDgtuSim::WriteTreesToFile() const {
	384	// write the trees holding tracklets and tracks to file
	385
52c19022	386	TFile *f = TFile::Open("TRD.GtuTracking.root", "RECREATE");
	387	f->cd();
	388	if (fTrackTree)
	389	f->WriteTObject(fTrackTree);
	390	if (fTrackletTree)
	391	f->WriteTObject(fTrackletTree);
	392	f->Close();
	393	return kTRUE;
	394	}
	395
36dc3337	396	Bool_t AliTRDgtuSim::WriteTracksToESD(const TList * const listOfTracks, AliESDEvent *esd)
52c19022	397	{
36dc3337	398	// fill the found tracks to the given ESD event
36dc3337	399
52c19022	400	if (esd) {
36dc3337	401	TIter next(listOfTracks);
52c19022	402	while (AliTRDtrackGTU trk = (AliTRDtrackGTU) next()) {
	403	AliESDTrdTrack *trdtrack = trk->CreateTrdTrack();
	404	esd->AddTrdTrack(trdtrack);
	405	delete trdtrack;
	406	}
	407	}
	408	return kTRUE;
	409	}
c8b1590d	410
	411	Bool_t AliTRDgtuSim::WriteTracksToLoader()
	412	{
36dc3337	413	// write the GTU tracks to the dedicated loader
	414	// these tracks contain more information than the ones in the ESD
	415
c8b1590d	416	if (!fTrackTree) {
	417	AliError("No track tree found!");
	418	return kFALSE;
	419	}
	420
	421	AliRunLoader *rl = AliRunLoader::Instance();
	422	AliDataLoader *dl = 0x0;
	423	if (rl)
	424	dl = rl->GetLoader("TRDLoader")->GetDataLoader("gtutracks");
	425	if (!dl) {
	426	AliError("Could not get the GTU-track data loader!");
	427	return kFALSE;
	428	}
	429
	430	TTree *trackTree = dl->Tree();
	431	if (!trackTree) {
	432	dl->MakeTree();
	433	trackTree = dl->Tree();
	434	}
	435
	436	AliTRDtrackGTU *trk = 0x0;
	437	TBranch *trkbranch = trackTree->GetBranch("TRDtrackGTU");
	438	if (!trkbranch)
	439	trkbranch = trackTree->Branch("TRDtrackGTU", "AliTRDtrackGTU", &trk, 32000);
	440
	441	TBranch *branch = fTrackTree->GetBranch("TRDgtuTrack");
	442	if (!branch)
	443	return kFALSE;
	444
	445	AliDebug(1,Form("Found %i tracks", branch->GetEntries()));
	446
	447	for (Int_t iTrack = 0; iTrack < branch->GetEntries(); iTrack++) {
	448	branch->SetAddress(&trk);
	449	branch->GetEntry(iTrack);
	450	trkbranch->SetAddress(&trk);
	451	trackTree->Fill();
	452	}
	453
	454	dl->WriteData("OVERWRITE");
	455
	456	return kTRUE;
	457	}