[u/mrichter/AliRoot.git] / MONITOR / monitorGDC.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$ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// this program performs local monitoring on a GDC by running the HLT code   //
//                                                                           //
// If an argument is given, this is taken as the name of a date file which   //
// is used instead of the local node.                                        //
// The program can be stopped by pressing CTRL-C.                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <TError.h>
#include <TSysEvtHandler.h>
#ifdef ALI_DATE
#include <TROOT.h>
#include <TSystem.h>
#include <TDatime.h>
#include "AliRawReaderDate.h"
#include "event.h"
#include "monitor.h"
/*
#include <AliHLTStandardIncludes.h>
#include <AliHLTTransform.h>
#include <AliHLTMemHandler.h>
#include <AliHLTTrackArray.h>
#include <AliHLTHoughMaxFinder.h>
#include <AliHLTHoughBaseTransformer.h>
#include <AliHLTHough.h>
#include <AliHLTBenchmark.h>
#include <AliHLTITSclusterer.h>
#include <AliHLTITSVertexerZ.h>
#include <AliHLTITStracker.h>
*/
#include "AliESDEvent.h"
#include "AliESDVertex.h"
#include "AliTracker.h"
#include <AliKalmanTrack.h>
#include "AliITSgeomTGeo.h"
#include "AliITSgeom.h"
#include "AliMagF.h"
#include "AliMagFMaps.h"
#endif

//_____________________________________________________________________________
class AliGDCInterruptHandler : public TSignalHandler {
public:
  AliGDCInterruptHandler();
  Bool_t Notify() {fStop = kTRUE; return kTRUE;};
  Bool_t Stop() const {return fStop;};
private:
  Bool_t fStop;  // CTRL-C pressed
};

//_____________________________________________________________________________
AliGDCInterruptHandler::AliGDCInterruptHandler() : 
  TSignalHandler(kSigInterrupt, kFALSE),
  fStop(kFALSE)
{

}


//_____________________________________________________________________________
#ifdef ALI_DATE
int main(int argc, char** argv)
{
  // set ROOT in batch mode
  gROOT->SetBatch();   

  // open a log file
  FILE* file = fopen("monitorGDC.log", "w");

  TDatime time;

  // get data from a file or online from this node
  Int_t status = 0;
  if (argc > 1) {
    status = monitorSetDataSource(argv[1]);
  } else {
    status = monitorSetDataSource(":");
  }
  if (status) ::Fatal("monitorSetDataSource", monitorDecodeError(status));

  // monitor only a sample of physics events
  char* table[] = {"Physics event", "yes", NULL};
  status = monitorDeclareTable(table);
  if (status) ::Fatal("monitorDeclareTable", monitorDecodeError(status));

  // declare this monitoring program to DATE
  status = monitorDeclareMp("GDC physics monitoring");
  if (status) ::Fatal("monitorDeclareMp", monitorDecodeError(status));

  // initialize HLT transformations
  //  if (!AliHLTTransform::Init("./", kFALSE)) {
  //    ::Fatal("AliHLTTransform::Init", "HLT initialization failed");
  //  }

  AliESDEvent *esd = new AliESDEvent;
  esd->CreateStdContent();

  //  AliITSgeom *geom = new AliITSgeom();
  //  geom->ReadNewFile("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymmFMD.det");
  //  if (!geom) return 1;
  //  Int_t sfield = 0;
  //  switch ((Int_t)(AliHLTTransform::GetSolenoidField()+0.5)) {
  //  case 2:
  //    sfield = AliMagFMaps::k2kG;
  //    break;
  //  case 4:
  //    sfield = AliMagFMaps::k4kG;
  //    break;
  //  case 5:
  //    sfield = AliMagFMaps::k5kG;
  //    break;
  //  default:
  //    ::Fatal("AliHLTTransform::GetSolenoidField", "Incorrect magnetic field");
  //  }
  AliMagF* field = new AliMagFMaps("Maps","Maps", 2, 1., 10., AliMagFMaps::k5kG);
  AliTracker::SetFieldMap(field,kTRUE);

  // Init PID
  AliPID pid;

  // create the signal handler
  AliGDCInterruptHandler* handler = new AliGDCInterruptHandler;
  gSystem->AddSignalHandler(handler);

  // endless loop
  void* ptr = NULL;
  while (!handler->Stop()) {
    // get the next event
    status = monitorGetEventDynamic(&ptr);
    if (status == (Int_t)MON_ERR_EOF) break;
    if (status) ::Fatal("monitorGetEventDynamic", monitorDecodeError(status));

    // if no new event
    if (!ptr) {
      gSystem->Sleep(1000);   // sleep for 1 second
      continue;
    }

    AliRawReaderDate rawReader(ptr);
    //    if ((rawReader.GetAttributes()[0] & 0x02) != 0) {

    //      Int_t errorCode = rawReader.CheckData();
    Int_t errorCode = 0;
      if (errorCode && (errorCode != AliRawReader::kErrSize)) {
	time.Set();
	if (file) fprintf(file, "%s\n", time.AsString());
	if (file) fprintf(file, "run: %d  event: %d %d\n", 
			  rawReader.GetRunNumber(), 
			  rawReader.GetEventId()[0], 
			  rawReader.GetEventId()[1]);
	fprintf(file, "ERROR: %d\n\n", errorCode);

      } else {

// 	AliHLTBenchmark *fBenchmark = new AliHLTBenchmark();
// 	fBenchmark->Start("Overall timing");

// 	// ITS clusterer and vertexer
// 	fBenchmark->Start("ITS Clusterer");
// 	AliHLTITSclusterer clusterer(0);
// 	AliRawReader *itsrawreader=new AliRawReaderDate(ptr);
// 	TTree* treeClusters = new TTree("TreeL3ITSclusters"," "); //make a tree
// 	clusterer.Digits2Clusters(itsrawreader,treeClusters);
// 	fBenchmark->Stop("ITS Clusterer");
	
// 	AliHLTITSVertexerZ vertexer;
// 	AliESDVertex *vertex = vertexer.FindVertexForCurrentEvent(geom,treeClusters);
// 	Double_t vtxPos[3];
// 	Double_t vtxErr[3]={0.005,0.005,0.010};
// 	vertex->GetXYZ(vtxPos);
// 	//	vertex->GetSigmaXYZ(vtxErr);
// 	esd->SetVertex(vertex);

// 	// TPC Hough reconstruction
// 	Float_t ptmin = 0.1*AliHLTTransform::GetSolenoidField();
// 	Float_t zvertex = vtxPos[2];

// 	// Run the Hough Transformer
// 	fBenchmark->Start("Init");
// 	AliHLTHough *hough1 = new AliHLTHough();

// 	hough1->SetThreshold(4);
// 	hough1->CalcTransformerParams(ptmin);
// 	hough1->SetPeakThreshold(70,-1);
// 	//	printf("Pointer is %x\n",ptr);
// 	hough1->Init("./", kFALSE, 100, kFALSE,4,0,(Char_t*)ptr,zvertex);
// 	hough1->SetAddHistograms();
// 	fBenchmark->Stop("Init");

// 	fBenchmark->Start("Init");
// 	AliHLTHough *hough2 = new AliHLTHough();

// 	hough2->SetThreshold(4);
// 	hough2->CalcTransformerParams(ptmin);
// 	hough2->SetPeakThreshold(70,-1);
// 	//	printf("Pointer is %x\n",ptr);
// 	hough2->Init("./", kFALSE, 100, kFALSE,4,0,(Char_t*)ptr,zvertex);
// 	hough2->SetAddHistograms();
// 	fBenchmark->Stop("Init");

// 	Int_t nglobaltracks = 0;
// 	/*
// 	hough1->StartProcessInThread(0,17);
// 	hough2->StartProcessInThread(18,35);

// 	//	gSystem->Sleep(20000);
// 	if(hough1->WaitForThreadFinish())
// 	  ::Fatal("AliHLTHough::WaitForThreadFinish"," Can not join the required thread! ");
// 	if(hough2->WaitForThreadFinish())
// 	  ::Fatal("AliHLTHough::WaitForThreadFinish"," Can not join the required thread! ");

// 	gSystem->MakeDirectory("hough1");
// 	hough1->WriteTracks("./hough1");
// 	gSystem->MakeDirectory("hough2");
// 	hough2->WriteTracks("./hough2");
// 	*/

// 	for(int slice=0; slice<=17; slice++)
// 	{
// 	  //	  cout<<"Processing slice "<<slice<<endl;
// 	  fBenchmark->Start("ReadData");
// 	  hough1->ReadData(slice,0);
// 	  fBenchmark->Stop("ReadData");
// 	  fBenchmark->Start("Transform");
// 	  hough1->Transform();
// 	  fBenchmark->Stop("Transform");
// 	  hough1->AddAllHistogramsRows();
// 	  hough1->FindTrackCandidatesRow();
// 	  fBenchmark->Start("AddTracks");
// 	  hough1->AddTracks();
// 	  fBenchmark->Stop("AddTracks");

// 	  //	  AliHLTTrackArray* tracks = (AliHLTTrackArray*)hough1->GetTracks(0);
// 	  //	  nglobaltracks += tracks->GetNTracks();
// 	}
// 	for(int slice=18; slice<=35; slice++)
// 	{
// 	  //	  cout<<"Processing slice "<<slice<<endl;
// 	  fBenchmark->Start("ReadData");
// 	  hough2->ReadData(slice,0);
// 	  fBenchmark->Stop("ReadData");
// 	  fBenchmark->Start("Transform");
// 	  hough2->Transform();
// 	  fBenchmark->Stop("Transform");
// 	  hough2->AddAllHistogramsRows();
// 	  hough2->FindTrackCandidatesRow();
// 	  fBenchmark->Start("AddTracks");
// 	  hough2->AddTracks();
// 	  fBenchmark->Stop("AddTracks");

// 	  //	  AliHLTTrackArray* tracks = (AliHLTTrackArray*)hough2->GetTracks(0);
// 	  //	  nglobaltracks += tracks->GetNTracks();
// 	}

// 	nglobaltracks += hough1->FillESD(esd);
// 	nglobaltracks += hough2->FillESD(esd);

// 	// ITS tracker
// 	AliHLTITStracker itsTracker(0);
// 	itsTracker.SetVertex(vtxPos,vtxErr);

// 	itsTracker.LoadClusters(treeClusters);
// 	itsTracker.Clusters2Tracks(esd);
// 	itsTracker.UnloadClusters();

// 	fBenchmark->Stop("Overall timing");
// 	time.Set();
// 	if (file) fprintf(file, "%s\n", time.AsString());
// 	if (file) fprintf(file, "run: %d  event: %d %d\n", 
// 			  rawReader.GetRunNumber(), 
// 			  rawReader.GetEventId()[0], 
// 			  rawReader.GetEventId()[1]);
// 	if (errorCode) fprintf(file, "ERROR: %d\n", errorCode);

// 	if (file) fprintf(file, "Hough Transformer found %d tracks\n",nglobaltracks);

// 	hough1->DoBench("hough1");
// 	hough2->DoBench("hough2");
// 	fBenchmark->Analyze("overall");
// 	if (file) {
// 	  FILE* bench = fopen("hough1.dat", "r");
// 	  while (bench && !feof(bench)) {
// 	    char buffer[256];
// 	    if (!fgets(buffer, 256, bench)) break;
// 	    fprintf(file, "%s", buffer);
// 	  }
// 	  fclose(bench);
// 	}
// 	if (file) {
// 	  FILE* bench = fopen("hough2.dat", "r");
// 	  while (bench && !feof(bench)) {
// 	    char buffer[256];
// 	    if (!fgets(buffer, 256, bench)) break;
// 	    fprintf(file, "%s", buffer);
// 	  }
// 	  fclose(bench);
// 	}
// 	if (file) {
// 	  FILE* bench = fopen("overall.dat", "r");
// 	  while (bench && !feof(bench)) {
// 	    char buffer[256];
// 	    if (!fgets(buffer, 256, bench)) break;
// 	    fprintf(file, "%s", buffer);
// 	  }
// 	  fclose(bench);
// 	  fprintf(file, "\n\n");
// 	}

// 	delete hough1;
// 	delete hough2;

// 	esd->Reset();
      }
    //    }

    /*
    // read run, event, detector, DDL numbers and data size
    AliRawReaderDate rawReader(ptr);
    time.Set();
    printf("\n%s\n", time.AsString());
    printf("run: %d  event: %d %d\n", rawReader.GetRunNumber(), 
	   rawReader.GetEventId()[0], rawReader.GetEventId()[1]);
    while (rawReader.ReadMiniHeader()) {
      printf(" detector: %d   DDL: %d  size: %d\n", 
	     rawReader.GetDetectorID(), rawReader.GetDDLID(), 
	     rawReader.GetDataSize());
    }

    */

    gSystem->Sleep(100);   // sleep for 0.1 second
    free(ptr);

    gSystem->ProcessEvents();
    if (file) fflush(file);

  }

  gSystem->RemoveSignalHandler(handler);
  if (file) fclose(file);

  return 0;
}

#else
int main(int /*argc*/, char** /*argv*/)
{
  ::Fatal("main", "this program was compiled without DATE");

  return 1;
}
#endif
Commit	Line	Data
b5279783	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$ */
	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// this program performs local monitoring on a GDC by running the HLT code //
	21	// //
	22	// If an argument is given, this is taken as the name of a date file which //
	23	// is used instead of the local node. //
	24	// The program can be stopped by pressing CTRL-C. //
	25	// //
	26	///////////////////////////////////////////////////////////////////////////////
	27
	28	#include <TError.h>
8ecba4b2	29	#include <TSysEvtHandler.h>
8c50acf2	30	#ifdef ALI_DATE
b5279783	31	#include <TROOT.h>
b5279783	32	#include <TSystem.h>
b5279783	33	#include <TDatime.h>
	34	#include "AliRawReaderDate.h"
	35	#include "event.h"
	36	#include "monitor.h"
cae21299	37	/*
4aa41877	38	#include <AliHLTStandardIncludes.h>
	39	#include <AliHLTTransform.h>
	40	#include <AliHLTMemHandler.h>
	41	#include <AliHLTTrackArray.h>
	42	#include <AliHLTHoughMaxFinder.h>
	43	#include <AliHLTHoughBaseTransformer.h>
	44	#include <AliHLTHough.h>
	45	#include <AliHLTBenchmark.h>
cae21299	46	#include <AliHLTITSclusterer.h>
	47	#include <AliHLTITSVertexerZ.h>
	48	#include <AliHLTITStracker.h>
	49	*/
	50	#include "AliESDEvent.h"
ede6ca10	51	#include "AliESDVertex.h"
cae21299	52	#include "AliTracker.h"
b77a0228	53	#include <AliKalmanTrack.h>
ad693bc1	54	#include "AliITSgeomTGeo.h"
f7ea67db	55	#include "AliITSgeom.h"
b77a0228	56	#include "AliMagF.h"
b77a0228	57	#include "AliMagFMaps.h"
b5279783	58	#endif
b5279783	59
b5279783	60	//_____________________________________________________________________________
	61	class AliGDCInterruptHandler : public TSignalHandler {
	62	public:
	63	AliGDCInterruptHandler();
	64	Bool_t Notify() {fStop = kTRUE; return kTRUE;};
	65	Bool_t Stop() const {return fStop;};
	66	private:
	67	Bool_t fStop; // CTRL-C pressed
	68	};
	69
	70	//_____________________________________________________________________________
	71	AliGDCInterruptHandler::AliGDCInterruptHandler() :
e41f1e44	72	TSignalHandler(kSigInterrupt, kFALSE),
e41f1e44	73	fStop(kFALSE)
b5279783	74	{
e41f1e44	75
cae21299	76	}
b5279783	77
	78
	79	//_____________________________________________________________________________
8c50acf2	80	#ifdef ALI_DATE
120b3c73	81	int main(int argc, char** argv)
120b3c73	82	{
b5279783	83	// set ROOT in batch mode
	84	gROOT->SetBatch();
	85
	86	// open a log file
	87	FILE* file = fopen("monitorGDC.log", "w");
a8ffd46b	88
b5279783	89	TDatime time;
	90
	91	// get data from a file or online from this node
	92	Int_t status = 0;
	93	if (argc > 1) {
	94	status = monitorSetDataSource(argv[1]);
	95	} else {
	96	status = monitorSetDataSource(":");
	97	}
	98	if (status) ::Fatal("monitorSetDataSource", monitorDecodeError(status));
	99
	100	// monitor only a sample of physics events
	101	char* table[] = {"Physics event", "yes", NULL};
	102	status = monitorDeclareTable(table);
	103	if (status) ::Fatal("monitorDeclareTable", monitorDecodeError(status));
	104
	105	// declare this monitoring program to DATE
04b48a95	106	status = monitorDeclareMp("GDC physics monitoring");
b5279783	107	if (status) ::Fatal("monitorDeclareMp", monitorDecodeError(status));
b5279783	108
b5279783	109	// initialize HLT transformations
cae21299	110	// if (!AliHLTTransform::Init("./", kFALSE)) {
	111	// ::Fatal("AliHLTTransform::Init", "HLT initialization failed");
	112	// }
	113
af885e0f	114	AliESDEvent *esd = new AliESDEvent;
af885e0f	115	esd->CreateStdContent();
cae21299	116
	117	// AliITSgeom *geom = new AliITSgeom();
	118	// geom->ReadNewFile("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymmFMD.det");
	119	// if (!geom) return 1;
	120	// Int_t sfield = 0;
	121	// switch ((Int_t)(AliHLTTransform::GetSolenoidField()+0.5)) {
	122	// case 2:
	123	// sfield = AliMagFMaps::k2kG;
	124	// break;
	125	// case 4:
	126	// sfield = AliMagFMaps::k4kG;
	127	// break;
	128	// case 5:
	129	// sfield = AliMagFMaps::k5kG;
	130	// break;
	131	// default:
	132	// ::Fatal("AliHLTTransform::GetSolenoidField", "Incorrect magnetic field");
	133	// }
	134	AliMagF* field = new AliMagFMaps("Maps","Maps", 2, 1., 10., AliMagFMaps::k5kG);
aa95f9f7	135	AliTracker::SetFieldMap(field,kTRUE);
	136
	137	// Init PID
	138	AliPID pid;
b5279783	139
	140	// create the signal handler
	141	AliGDCInterruptHandler* handler = new AliGDCInterruptHandler;
	142	gSystem->AddSignalHandler(handler);
	143
	144	// endless loop
	145	void* ptr = NULL;
	146	while (!handler->Stop()) {
	147	// get the next event
	148	status = monitorGetEventDynamic(&ptr);
	149	if (status == (Int_t)MON_ERR_EOF) break;
	150	if (status) ::Fatal("monitorGetEventDynamic", monitorDecodeError(status));
	151
	152	// if no new event
	153	if (!ptr) {
	154	gSystem->Sleep(1000); // sleep for 1 second
	155	continue;
	156	}
	157
04b48a95	158	AliRawReaderDate rawReader(ptr);
a8ffd46b	159	// if ((rawReader.GetAttributes()[0] & 0x02) != 0) {
04b48a95	160
a8ffd46b	161	// Int_t errorCode = rawReader.CheckData();
a8ffd46b	162	Int_t errorCode = 0;
3256212a	163	if (errorCode && (errorCode != AliRawReader::kErrSize)) {
	164	time.Set();
	165	if (file) fprintf(file, "%s\n", time.AsString());
	166	if (file) fprintf(file, "run: %d event: %d %d\n",
	167	rawReader.GetRunNumber(),
	168	rawReader.GetEventId()[0],
	169	rawReader.GetEventId()[1]);
	170	fprintf(file, "ERROR: %d\n\n", errorCode);
	171
	172	} else {
	173
cae21299	174	// AliHLTBenchmark *fBenchmark = new AliHLTBenchmark();
cae21299	175	// fBenchmark->Start("Overall timing");
a8ffd46b	176
cae21299	177	// // ITS clusterer and vertexer
	178	// fBenchmark->Start("ITS Clusterer");
	179	// AliHLTITSclusterer clusterer(0);
	180	// AliRawReader *itsrawreader=new AliRawReaderDate(ptr);
	181	// TTree* treeClusters = new TTree("TreeL3ITSclusters"," "); //make a tree
	182	// clusterer.Digits2Clusters(itsrawreader,treeClusters);
	183	// fBenchmark->Stop("ITS Clusterer");
b77a0228	184
cae21299	185	// AliHLTITSVertexerZ vertexer;
	186	// AliESDVertex *vertex = vertexer.FindVertexForCurrentEvent(geom,treeClusters);
	187	// Double_t vtxPos[3];
	188	// Double_t vtxErr[3]={0.005,0.005,0.010};
	189	// vertex->GetXYZ(vtxPos);
	190	// // vertex->GetSigmaXYZ(vtxErr);
	191	// esd->SetVertex(vertex);
	192
	193	// // TPC Hough reconstruction
	194	// Float_t ptmin = 0.1*AliHLTTransform::GetSolenoidField();
	195	// Float_t zvertex = vtxPos[2];
	196
	197	// // Run the Hough Transformer
	198	// fBenchmark->Start("Init");
	199	// AliHLTHough *hough1 = new AliHLTHough();
	200
	201	// hough1->SetThreshold(4);
	202	// hough1->CalcTransformerParams(ptmin);
	203	// hough1->SetPeakThreshold(70,-1);
	204	// // printf("Pointer is %x\n",ptr);
	205	// hough1->Init("./", kFALSE, 100, kFALSE,4,0,(Char_t*)ptr,zvertex);
	206	// hough1->SetAddHistograms();
	207	// fBenchmark->Stop("Init");
	208
	209	// fBenchmark->Start("Init");
	210	// AliHLTHough *hough2 = new AliHLTHough();
	211
	212	// hough2->SetThreshold(4);
	213	// hough2->CalcTransformerParams(ptmin);
	214	// hough2->SetPeakThreshold(70,-1);
	215	// // printf("Pointer is %x\n",ptr);
	216	// hough2->Init("./", kFALSE, 100, kFALSE,4,0,(Char_t*)ptr,zvertex);
	217	// hough2->SetAddHistograms();
	218	// fBenchmark->Stop("Init");
	219
	220	// Int_t nglobaltracks = 0;
	221	// /*
	222	// hough1->StartProcessInThread(0,17);
	223	// hough2->StartProcessInThread(18,35);
	224
	225	// // gSystem->Sleep(20000);
	226	// if(hough1->WaitForThreadFinish())
	227	// ::Fatal("AliHLTHough::WaitForThreadFinish"," Can not join the required thread! ");
	228	// if(hough2->WaitForThreadFinish())
	229	// ::Fatal("AliHLTHough::WaitForThreadFinish"," Can not join the required thread! ");
	230
	231	// gSystem->MakeDirectory("hough1");
	232	// hough1->WriteTracks("./hough1");
	233	// gSystem->MakeDirectory("hough2");
	234	// hough2->WriteTracks("./hough2");
	235	// */
	236
	237	// for(int slice=0; slice<=17; slice++)
	238	// {
	239	// // cout<<"Processing slice "<<slice<<endl;
	240	// fBenchmark->Start("ReadData");
	241	// hough1->ReadData(slice,0);
	242	// fBenchmark->Stop("ReadData");
	243	// fBenchmark->Start("Transform");
	244	// hough1->Transform();
	245	// fBenchmark->Stop("Transform");
	246	// hough1->AddAllHistogramsRows();
	247	// hough1->FindTrackCandidatesRow();
	248	// fBenchmark->Start("AddTracks");
249	// hough1->AddTracks();
250	// fBenchmark->Stop("AddTracks");
251
252	// // AliHLTTrackArray* tracks = (AliHLTTrackArray*)hough1->GetTracks(0);
253	// // nglobaltracks += tracks->GetNTracks();
254	// }
255	// for(int slice=18; slice<=35; slice++)
256	// {
257	// // cout<<"Processing slice "<<slice<<endl;
258	// fBenchmark->Start("ReadData");
259	// hough2->ReadData(slice,0);
260	// fBenchmark->Stop("ReadData");
261	// fBenchmark->Start("Transform");
262	// hough2->Transform();
263	// fBenchmark->Stop("Transform");
264	// hough2->AddAllHistogramsRows();
265	// hough2->FindTrackCandidatesRow();
266	// fBenchmark->Start("AddTracks");
267	// hough2->AddTracks();
268	// fBenchmark->Stop("AddTracks");
269
270	// // AliHLTTrackArray* tracks = (AliHLTTrackArray*)hough2->GetTracks(0);
271	// // nglobaltracks += tracks->GetNTracks();
272	// }
273
274	// nglobaltracks += hough1->FillESD(esd);
275	// nglobaltracks += hough2->FillESD(esd);
276
277	// // ITS tracker
278	// AliHLTITStracker itsTracker(0);
279	// itsTracker.SetVertex(vtxPos,vtxErr);
280
281	// itsTracker.LoadClusters(treeClusters);
282	// itsTracker.Clusters2Tracks(esd);
283	// itsTracker.UnloadClusters();
284
285	// fBenchmark->Stop("Overall timing");
286	// time.Set();
287	// if (file) fprintf(file, "%s\n", time.AsString());
288	// if (file) fprintf(file, "run: %d event: %d %d\n",
289	// rawReader.GetRunNumber(),
290	// rawReader.GetEventId()[0],
291	// rawReader.GetEventId()[1]);
292	// if (errorCode) fprintf(file, "ERROR: %d\n", errorCode);
293
294	// if (file) fprintf(file, "Hough Transformer found %d tracks\n",nglobaltracks);
295
296	// hough1->DoBench("hough1");
297	// hough2->DoBench("hough2");
298	// fBenchmark->Analyze("overall");
299	// if (file) {
300	// FILE* bench = fopen("hough1.dat", "r");
301	// while (bench && !feof(bench)) {
302	// char buffer[256];
303	// if (!fgets(buffer, 256, bench)) break;
304	// fprintf(file, "%s", buffer);
305	// }
306	// fclose(bench);
307	// }
308	// if (file) {
309	// FILE* bench = fopen("hough2.dat", "r");
310	// while (bench && !feof(bench)) {
311	// char buffer[256];
312	// if (!fgets(buffer, 256, bench)) break;
313	// fprintf(file, "%s", buffer);
314	// }
315	// fclose(bench);
316	// }
317	// if (file) {
318	// FILE* bench = fopen("overall.dat", "r");
319	// while (bench && !feof(bench)) {
320	// char buffer[256];
321	// if (!fgets(buffer, 256, bench)) break;
322	// fprintf(file, "%s", buffer);
323	// }
324	// fclose(bench);
325	// fprintf(file, "\n\n");
326	// }
327
328	// delete hough1;
329	// delete hough2;
330
331	// esd->Reset();
3256212a	332	}
a8ffd46b	333	// }
	334
	335	/*
	336	// read run, event, detector, DDL numbers and data size
	337	AliRawReaderDate rawReader(ptr);
	338	time.Set();
	339	printf("\n%s\n", time.AsString());
	340	printf("run: %d event: %d %d\n", rawReader.GetRunNumber(),
	341	rawReader.GetEventId()[0], rawReader.GetEventId()[1]);
	342	while (rawReader.ReadMiniHeader()) {
	343	printf(" detector: %d DDL: %d size: %d\n",
	344	rawReader.GetDetectorID(), rawReader.GetDDLID(),
	345	rawReader.GetDataSize());
04b48a95	346	}
b5279783	347
a8ffd46b	348	*/
a8ffd46b	349
df0f3179	350	gSystem->Sleep(100); // sleep for 0.1 second
b5279783	351	free(ptr);
	352
	353	gSystem->ProcessEvents();
	354	if (file) fflush(file);
a8ffd46b	355
b5279783	356	}
	357
	358	gSystem->RemoveSignalHandler(handler);
	359	if (file) fclose(file);
	360
120b3c73	361	return 0;
	362	}
	363
b5279783	364	#else
120b3c73	365	int main(int /argc/, char** /argv/)
120b3c73	366	{
b5279783	367	::Fatal("main", "this program was compiled without DATE");
b5279783	368
120b3c73	369	return 1;
b5279783	370	}
120b3c73	371	#endif