[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));
	((AliTRDtrackletGTU *)((*fTrackletArray)[fTrackletArray->GetEntries()-1]))->SetMCMtrackletIndex(iTracklet);
      }
      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
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"
44eafcf2	32	#include "TObject.h"
52c19022	33	#include "TClonesArray.h"
52c19022	34
4d6aee34	35	#include "AliRun.h"
	36	#include "AliRunLoader.h"
	37	#include "AliLoader.h"
f7247d06	38	#include "AliTreeLoader.h"
4d6aee34	39	#include "AliLog.h"
4d6aee34	40	#include "AliESDTrdTrack.h"
44eafcf2	41	#include "AliESDTrdTracklet.h"
4d6aee34	42
52c19022	43	#include "AliTRDgtuSim.h"
c1ad4629	44	#include "AliTRDfeeParam.h"
52c19022	45	#include "AliTRDgtuTMU.h"
	46	#include "AliTRDtrackGTU.h"
	47	#include "AliTRDtrackletWord.h"
	48	#include "AliTRDtrackletMCM.h"
	49	#include "AliESDEvent.h"
52c19022	50
	51	ClassImp(AliTRDgtuSim)
	52
5f006bd7	53	AliTRDgtuSim::AliTRDgtuSim(AliRunLoader *rl)
52c19022	54	: TObject(),
52c19022	55	fRunLoader(rl),
c1ad4629	56	fFeeParam(AliTRDfeeParam::Instance()),
52c19022	57	fTMU(0x0),
b5d16822	58	fTrackletArray(0x0)
52c19022	59	{
b5d16822	60
52c19022	61	}
52c19022	62
5f006bd7	63	AliTRDgtuSim::~AliTRDgtuSim()
52c19022	64	{
36dc3337	65	// destructor
36dc3337	66
52c19022	67	if (fTrackletArray)
44eafcf2	68	fTrackletArray->Clear();
52c19022	69	delete fTrackletArray;
52c19022	70	}
52c19022	71
5f006bd7	72	Bool_t AliTRDgtuSim::RunGTUFromTrackletFile(TString filename, Int_t event, Int_t noev)
52c19022	73	{
5f006bd7	74	// run the GTU from a file of tracklets
36dc3337	75	// used for comparison to VHDL simulation
36dc3337	76
44eafcf2	77	ifstream input(filename.Data());
5f006bd7	78
44eafcf2	79	std::string str;
	80	TString string;
	81	int lineno = 0;
5f006bd7	82
44eafcf2	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;
5f006bd7	91
44eafcf2	92	fTMU = 0x0;
5f006bd7	93
44eafcf2	94	TClonesArray trklArray("AliTRDtrackletWord", 100);
44eafcf2	95	TClonesArray trklArrayGTU("AliTRDtrackletGTU", 100);
5f006bd7	96
44eafcf2	97	AliDebug(1, Form("--------- Reading from %s ----------", filename.Data()));
	98	while (getline(input, str)) {
	99	lineno++;
	100	string = str;
52c19022	101
44eafcf2	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	}
52c19022	107
44eafcf2	108	if ( ((TObjString*) tokens->At(0))->GetString().Atoi() < event)
44eafcf2	109	continue;
52c19022	110
44eafcf2	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();
5f006bd7	115
44eafcf2	116	if ((iEvent != iEventPrev) \|\|
	117	(iStack != iStackPrev) \|\|
	118	(iSec != iSecPrev)) {
	119	if(fTMU) {
36dc3337	120	TList *listOfTracks = new TList();
52c19022	121	fTMU->SetStack(iStackPrev);
52c19022	122	fTMU->SetSector(iSecPrev);
36dc3337	123	fTMU->RunTMU(listOfTracks);
44eafcf2	124	AliDebug(1,Form("--- There are %i tracks. Writing ...", listOfTracks->GetEntries()));
36dc3337	125	WriteTracksToDataFile(listOfTracks, iEventPrev);
44eafcf2	126	if (listOfTracks->GetEntries() > 0)
44eafcf2	127	AliDebug(2,Form(" %4.1f GeV/c", ((AliTRDtrackGTU*) listOfTracks->At(0))->GetPt() ));
52c19022	128	delete fTMU;
44eafcf2	129	fTMU = new AliTRDgtuTMU();
36dc3337	130	delete listOfTracks;
44eafcf2	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);
52c19022	153	}
44eafcf2	154	}
52c19022	155
44eafcf2	156	if (fTMU && evcnt < noev) {
	157	TList *listOfTracks = new TList();
	158	fTMU->SetStack(iStackPrev);
	159	fTMU->SetSector(iSecPrev);
	160	fTMU->RunTMU(listOfTracks);
44eafcf2	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;
52c19022	169	}
52c19022	170
5f006bd7	171	Bool_t AliTRDgtuSim::RunGTU(AliLoader loader, AliESDEvent esd)
52c19022	172	{
36dc3337	173	// run the GTU on tracklets taken from the loader
5f006bd7	174	// if specified the GTU tracks are written to the ESD event
36dc3337	175
c1ad4629	176	if (!fFeeParam->GetTracklet())
	177	return kFALSE;
	178
44eafcf2	179	if (fTrackletArray)
	180	fTrackletArray->Clear();
	181
	182	if (loader) {
52c19022	183	if (!LoadTracklets(loader)) {
a8518fd2	184	AliError("Could not load the tracklets. Nothing done ...");
52c19022	185	return kFALSE;
52c19022	186	}
44eafcf2	187	}
	188	else {
	189	LoadTracklets(esd);
	190	}
52c19022	191
f7247d06	192	AliDebug(1, Form("running on %i tracklets", fTrackletArray->GetEntriesFast()));
f7247d06	193
52c19022	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	}
5f006bd7	204
36dc3337	205	TList *listOfTracks = new TList();
5f006bd7	206
52c19022	207	TIter next(fTrackletArray);
52c19022	208
44eafcf2	209	while (AliTRDtrackletGTU trkl = (AliTRDtrackletGTU) next()) {
52c19022	210	iSec = trkl->GetDetector() / 30;
52c19022	211	iStack = (trkl->GetDetector() % 30) / 6;
44eafcf2	212	iLink = trkl->GetHCId() % 12;
52c19022	213
	214	if (iStack != iStackPrev \|\| iSec != iSecPrev) {
	215	if(fTMU) {
	216	fTMU->SetStack(iStackPrev);
	217	fTMU->SetSector(iSecPrev);
36dc3337	218	fTMU->RunTMU(listOfTracks);
2cf67435	219	WriteTracksToLoader(listOfTracks);
36dc3337	220	WriteTracksToESD(listOfTracks, esd);
52c19022	221	fTMU->Reset();
36dc3337	222	listOfTracks->Delete();
52c19022	223	} else {
	224	fTMU = new AliTRDgtuTMU();
	225	}
	226	iStackPrev = iStack;
	227	iSecPrev = iSec;
d2c8b010	228	AliDebug(1, Form("now in sec %i, stack %i", iSec, iStack));
52c19022	229	}
d2c8b010	230	AliDebug(1, Form("adding tracklet: 0x%08x in sec %i stack %i link %i",
d2c8b010	231	trkl->GetTrackletWord(), trkl->GetDetector() / 30, (trkl->GetDetector() % 30) / 6, trkl->GetHCId() % 12));
44eafcf2	232	if (fTMU) {
637666cd	233	fTMU->AddTracklet(trkl, iLink);
44eafcf2	234	}
52c19022	235	}
5f006bd7	236
52c19022	237	if (fTMU) {
	238	fTMU->SetStack(iStackPrev);
	239	fTMU->SetSector(iSecPrev);
36dc3337	240	fTMU->RunTMU(listOfTracks);
2cf67435	241	WriteTracksToLoader(listOfTracks);
36dc3337	242	WriteTracksToESD(listOfTracks, esd);
52c19022	243	delete fTMU;
52c19022	244	fTMU = 0x0;
36dc3337	245	listOfTracks->Delete();
52c19022	246	}
52c19022	247
36dc3337	248	delete listOfTracks;
52c19022	249
	250	return kTRUE;
	251	}
	252
44eafcf2	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
5f006bd7	268	Bool_t AliTRDgtuSim::LoadTracklets(AliLoader *const loader)
52c19022	269	{
36dc3337	270	// load the tracklets using the given loader
36dc3337	271
c8b1590d	272	AliDebug(1,"Loading tracklets ...");
52c19022	273
c1ad4629	274	if (!fFeeParam->GetTracklet())
	275	return kFALSE;
	276
52c19022	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();
f7247d06	289	TTree *trackletTree = 0x0;
52c19022	290
f7247d06	291	// simulated tracklets
	292	trackletTree = trackletLoader->Tree();
	293	if (trackletTree) {
	294	TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
	295	if (trklbranch) {
52c19022	296	if (!fTrackletArray)
44eafcf2	297	fTrackletArray = new TClonesArray("AliTRDtrackletGTU", 1000);
52c19022	298
44eafcf2	299	AliTRDtrackletMCM *trkl = 0x0;
52c19022	300	trklbranch->SetAddress(&trkl);
52c19022	301	for (Int_t iTracklet = 0; iTracklet < trklbranch->GetEntries(); iTracklet++) {
f7247d06	302	trklbranch->GetEntry(iTracklet);
44eafcf2	303	new ((fTrackletArray)[fTrackletArray->GetEntries()]) AliTRDtrackletGTU(new AliTRDtrackletMCM(trkl));
059f00c5	304	((AliTRDtrackletGTU )((fTrackletArray)[fTrackletArray->GetEntries()-1]))->SetMCMtrackletIndex(iTracklet);
52c19022	305	}
52c19022	306	return kTRUE;
f7247d06	307	}
52c19022	308	}
52c19022	309
f7247d06	310	// raw tracklets
	311	AliTreeLoader tl = (AliTreeLoader) trackletLoader->GetBaseLoader("tracklets-raw");
	312	trackletTree = tl ? tl->Load(), tl->Tree() : 0x0;
52c19022	313
f7247d06	314	if (trackletTree) {
f7247d06	315	if (!fTrackletArray)
44eafcf2	316	fTrackletArray = new TClonesArray("AliTRDtrackletGTU", 1000);
5f006bd7	317
5f006bd7	318	Int_t hc;
f7247d06	319	TClonesArray *ar = 0x0;
	320	trackletTree->SetBranchAddress("hc", &hc);
	321	trackletTree->SetBranchAddress("trkl", &ar);
	322
	323	for (Int_t iEntry = 0; iEntry < trackletTree->GetEntries(); iEntry++) {
	324	trackletTree->GetEntry(iEntry);
2cf67435	325	AliDebug(2, Form("%i tracklets in HC %i", ar->GetEntriesFast(), hc));
f7247d06	326	for (Int_t iTracklet = 0; iTracklet < ar->GetEntriesFast(); iTracklet++) {
f7247d06	327	AliTRDtrackletWord trklWord = (AliTRDtrackletWord) (*ar)[iTracklet];
44eafcf2	328	new((*fTrackletArray)[fTrackletArray->GetEntriesFast()]) AliTRDtrackletGTU(new AliTRDtrackletWord(trklWord->GetTrackletWord(), hc));
52c19022	329	}
f7247d06	330	}
f7247d06	331	return kTRUE;
52c19022	332	}
5f006bd7	333
f7247d06	334	AliError("No raw tracklet tree found\n");
52c19022	335
f7247d06	336	return kFALSE;
52c19022	337	}
52c19022	338
5f006bd7	339	Bool_t AliTRDgtuSim::WriteTracksToDataFile(TList *listOfTracks, Int_t event)
52c19022	340	{
36dc3337	341	// write the found tracks to a data file
	342	// used for comparison to VHDL simulation
	343
52c19022	344	Int_t sm = 0;
	345	Int_t stack = 0;
	346
	347	FILE *out;
	348	out = fopen("test.data", "a");
	349
36dc3337	350	AliDebug(1,Form("%i tracks found in event %i", listOfTracks->GetSize(), event));
44eafcf2	351	// fprintf(out, "0 %5i %2i %i 00000000\n", event, sm, stack);
36dc3337	352	for (Int_t i = 0; i < listOfTracks->GetSize(); i++) {
36dc3337	353	AliTRDtrackGTU trk = (AliTRDtrackGTU) listOfTracks->At(i);
52c19022	354	sm = trk->GetSector();
52c19022	355	stack = trk->GetStack();
44eafcf2	356
	357	ULong64_t trackWord = 1;
	358	AppendBits(trackWord, 1, 0);
	359	AppendBits(trackWord, 6, trk->GetTrackletMask());
	360	AppendBits(trackWord, 18, (Int_t) trk->GetA());
	361	AppendBits(trackWord, 18, (Int_t) trk->GetB());
	362	AppendBits(trackWord, 12, (Int_t) trk->GetC());
	363	AppendBits(trackWord, 8, trk->GetPID());
	364	fprintf(out, "ev. %i sec. %i stack %i - track word: 0x%016llx, ",
	365	event, sm, stack, trackWord);
	366
	367	trackWord = 0;
	368	AppendBits(trackWord, 11, 0); // flags
	369	AppendBits(trackWord, 3, 0);
	370	AppendBits(trackWord, 13, trk->GetYapprox());
	371	AppendBits(trackWord, 6, trk->GetTrackletIndex(5));
	372	AppendBits(trackWord, 6, trk->GetTrackletIndex(4));
	373	AppendBits(trackWord, 6, trk->GetTrackletIndex(3));
	374	AppendBits(trackWord, 6, trk->GetTrackletIndex(2));
	375	AppendBits(trackWord, 6, trk->GetTrackletIndex(1));
	376	AppendBits(trackWord, 6, trk->GetTrackletIndex(0));
	377	fprintf(out, "extended track word: 0x%016llx\n", trackWord);
	378
5f006bd7	379	fprintf(out, "1 %5i %2i %2i %3i %3i %3i %3i %3i %3i %3i %4i %f\n", event, sm, stack, trk->GetTrackletMask(),
	380	trk->GetTrackletIndex(5),
	381	trk->GetTrackletIndex(4),
	382	trk->GetTrackletIndex(3),
	383	trk->GetTrackletIndex(2),
	384	trk->GetTrackletIndex(1),
52c19022	385	trk->GetTrackletIndex(0),
5f006bd7	386	trk->GetPtInt(),
52c19022	387	trk->GetPt());
	388	}
	389	fclose(out);
	390	return kTRUE;
	391	}
	392
5f006bd7	393	Bool_t AliTRDgtuSim::WriteTracksToESD(const TList * const listOfTracks, AliESDEvent *esd)
52c19022	394	{
36dc3337	395	// fill the found tracks to the given ESD event
36dc3337	396
52c19022	397	if (esd) {
36dc3337	398	TIter next(listOfTracks);
52c19022	399	while (AliTRDtrackGTU trk = (AliTRDtrackGTU) next()) {
52c19022	400	AliESDTrdTrack *trdtrack = trk->CreateTrdTrack();
2cf67435	401	if (trdtrack->GetLabel() < 0)
2cf67435	402	trdtrack->SetLabel(-2);
52c19022	403	esd->AddTrdTrack(trdtrack);
	404	delete trdtrack;
	405	}
	406	}
	407	return kTRUE;
	408	}
c8b1590d	409
2cf67435	410	Bool_t AliTRDgtuSim::WriteTracksToLoader(const TList * const listOfTracks)
c8b1590d	411	{
36dc3337	412	// write the GTU tracks to the dedicated loader
	413	// these tracks contain more information than the ones in the ESD
	414
c8b1590d	415	AliRunLoader *rl = AliRunLoader::Instance();
	416	AliDataLoader *dl = 0x0;
	417	if (rl)
	418	dl = rl->GetLoader("TRDLoader")->GetDataLoader("gtutracks");
	419	if (!dl) {
	420	AliError("Could not get the GTU-track data loader!");
	421	return kFALSE;
	422	}
	423
	424	TTree *trackTree = dl->Tree();
	425	if (!trackTree) {
	426	dl->MakeTree();
	427	trackTree = dl->Tree();
	428	}
5f006bd7	429
c8b1590d	430	AliTRDtrackGTU *trk = 0x0;
2cf67435	431
f7247d06	432	if (!trackTree->GetBranch("TRDtrackGTU"))
f7247d06	433	trackTree->Branch("TRDtrackGTU", "AliTRDtrackGTU", &trk, 32000);
5f006bd7	434
b5d16822	435	AliDebug(1, Form("Writing %i tracks to loader", listOfTracks->GetEntries()));
2cf67435	436	TIter next(listOfTracks);
3512dabb	437	while ((trk = (AliTRDtrackGTU*) next())) {
f7247d06	438	trackTree->SetBranchAddress("TRDtrackGTU", &trk);
c8b1590d	439	trackTree->Fill();
	440	}
	441
	442	dl->WriteData("OVERWRITE");
	443
	444	return kTRUE;
	445	}