[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 DATE_SYS
#include <TROOT.h>
#include <TSystem.h>
#include <TDatime.h>
#include "AliRawReaderDate.h"
#include "event.h"
#include "monitor.h"
#include <AliL3StandardIncludes.h>
#include <AliL3Transform.h>
#include <AliL3MemHandler.h>
#include <AliL3TrackArray.h>
#include <AliL3HoughMaxFinder.h>
#include <AliL3HoughBaseTransformer.h>
#include <AliL3Hough.h>
#include <AliL3Benchmark.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 DATE_SYS
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 (!AliL3Transform::Init("./", kFALSE)) {
    ::Fatal("AliL3Transform::Init", "HLT initialization failed");
  }

  // 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 {

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

	Float_t ptmin = 0.1*AliL3Transform::GetSolenoidField();

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

	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,0.0);
	hough1->SetAddHistograms();
	fBenchmark->Stop("Init");

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

	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,0.0);
	hough2->SetAddHistograms();
	fBenchmark->Stop("Init");

	Int_t n_global_tracks = 0;
	hough1->StartProcessInThread(0,17);
	hough2->StartProcessInThread(18,35);

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

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

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

	  AliL3TrackArray* tracks = (AliL3TrackArray*)hough->GetTracks(0);
	  n_global_tracks += tracks->GetNTracks();
	}
	*/
	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",n_global_tracks);

	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;
      }
    //    }

    /*
    // 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>
b5279783	30	#ifdef DATE_SYS
	31	#include <TROOT.h>
	32	#include <TSystem.h>
b5279783	33	#include <TDatime.h>
	34	#include "AliRawReaderDate.h"
	35	#include "event.h"
	36	#include "monitor.h"
a8ffd46b	37	#include <AliL3StandardIncludes.h>
b5279783	38	#include <AliL3Transform.h>
	39	#include <AliL3MemHandler.h>
	40	#include <AliL3TrackArray.h>
a8ffd46b	41	#include <AliL3HoughMaxFinder.h>
	42	#include <AliL3HoughBaseTransformer.h>
	43	#include <AliL3Hough.h>
	44	#include <AliL3Benchmark.h>
b5279783	45	#endif
b5279783	46
	47
	48	//_____________________________________________________________________________
	49	class AliGDCInterruptHandler : public TSignalHandler {
	50	public:
	51	AliGDCInterruptHandler();
	52	Bool_t Notify() {fStop = kTRUE; return kTRUE;};
	53	Bool_t Stop() const {return fStop;};
	54	private:
	55	Bool_t fStop; // CTRL-C pressed
	56	};
	57
	58	//_____________________________________________________________________________
	59	AliGDCInterruptHandler::AliGDCInterruptHandler() :
	60	TSignalHandler(kSigInterrupt, kFALSE)
	61	{
	62	fStop = kFALSE;
	63	};
	64
	65
	66	//_____________________________________________________________________________
b5279783	67	#ifdef DATE_SYS
120b3c73	68	int main(int argc, char** argv)
120b3c73	69	{
b5279783	70	// set ROOT in batch mode
	71	gROOT->SetBatch();
	72
	73	// open a log file
	74	FILE* file = fopen("monitorGDC.log", "w");
a8ffd46b	75
b5279783	76	TDatime time;
	77
	78	// get data from a file or online from this node
	79	Int_t status = 0;
	80	if (argc > 1) {
	81	status = monitorSetDataSource(argv[1]);
	82	} else {
	83	status = monitorSetDataSource(":");
	84	}
	85	if (status) ::Fatal("monitorSetDataSource", monitorDecodeError(status));
	86
	87	// monitor only a sample of physics events
	88	char* table[] = {"Physics event", "yes", NULL};
	89	status = monitorDeclareTable(table);
	90	if (status) ::Fatal("monitorDeclareTable", monitorDecodeError(status));
	91
	92	// declare this monitoring program to DATE
04b48a95	93	status = monitorDeclareMp("GDC physics monitoring");
b5279783	94	if (status) ::Fatal("monitorDeclareMp", monitorDecodeError(status));
b5279783	95
b5279783	96	// initialize HLT transformations
	97	if (!AliL3Transform::Init("./", kFALSE)) {
	98	::Fatal("AliL3Transform::Init", "HLT initialization failed");
	99	}
b5279783	100
	101	// create the signal handler
	102	AliGDCInterruptHandler* handler = new AliGDCInterruptHandler;
	103	gSystem->AddSignalHandler(handler);
	104
	105	// endless loop
	106	void* ptr = NULL;
	107	while (!handler->Stop()) {
	108	// get the next event
	109	status = monitorGetEventDynamic(&ptr);
	110	if (status == (Int_t)MON_ERR_EOF) break;
	111	if (status) ::Fatal("monitorGetEventDynamic", monitorDecodeError(status));
	112
	113	// if no new event
	114	if (!ptr) {
	115	gSystem->Sleep(1000); // sleep for 1 second
	116	continue;
	117	}
	118
04b48a95	119	AliRawReaderDate rawReader(ptr);
a8ffd46b	120	// if ((rawReader.GetAttributes()[0] & 0x02) != 0) {
04b48a95	121
a8ffd46b	122	// Int_t errorCode = rawReader.CheckData();
a8ffd46b	123	Int_t errorCode = 0;
3256212a	124	if (errorCode && (errorCode != AliRawReader::kErrSize)) {
	125	time.Set();
	126	if (file) fprintf(file, "%s\n", time.AsString());
	127	if (file) fprintf(file, "run: %d event: %d %d\n",
	128	rawReader.GetRunNumber(),
	129	rawReader.GetEventId()[0],
	130	rawReader.GetEventId()[1]);
	131	fprintf(file, "ERROR: %d\n\n", errorCode);
	132
	133	} else {
	134
a8ffd46b	135	AliL3Benchmark *fBenchmark = new AliL3Benchmark();
	136	fBenchmark->Start("Overall timing");
	137
add57a93	138	Float_t ptmin = 0.1*AliL3Transform::GetSolenoidField();
add57a93	139
a8ffd46b	140	// Run the Hough Transformer
	141	fBenchmark->Start("Init");
	142	AliL3Hough *hough1 = new AliL3Hough();
	143
	144	hough1->SetThreshold(4);
add57a93	145	hough1->CalcTransformerParams(ptmin);
a8ffd46b	146	hough1->SetPeakThreshold(70,-1);
a8ffd46b	147	// printf("Pointer is %x\n",ptr);
1e75562a	148	hough1->Init("./", kFALSE, 100, kFALSE,4,0,(Char_t*)ptr,0.0);
a8ffd46b	149	hough1->SetAddHistograms();
	150	fBenchmark->Stop("Init");
	151
	152	fBenchmark->Start("Init");
	153	AliL3Hough *hough2 = new AliL3Hough();
	154
	155	hough2->SetThreshold(4);
add57a93	156	hough2->CalcTransformerParams(ptmin);
a8ffd46b	157	hough2->SetPeakThreshold(70,-1);
a8ffd46b	158	// printf("Pointer is %x\n",ptr);
1e75562a	159	hough2->Init("./", kFALSE, 100, kFALSE,4,0,(Char_t*)ptr,0.0);
a8ffd46b	160	hough2->SetAddHistograms();
	161	fBenchmark->Stop("Init");
	162
	163	Int_t n_global_tracks = 0;
	164	hough1->StartProcessInThread(0,17);
	165	hough2->StartProcessInThread(18,35);
	166
	167	// gSystem->Sleep(20000);
	168	if(hough1->WaitForThreadFinish())
	169	::Fatal("AliL3Hough::WaitForThreadFinish"," Can not join the required thread! ");
	170	if(hough2->WaitForThreadFinish())
	171	::Fatal("AliL3Hough::WaitForThreadFinish"," Can not join the required thread! ");
	172
	173	gSystem->MakeDirectory("hough1");
	174	hough1->WriteTracks("./hough1");
	175	gSystem->MakeDirectory("hough2");
	176	hough2->WriteTracks("./hough2");
	177
	178	/*
	179	for(int slice=0; slice<=35; slice++)
	180	{
	181	// cout<<"Processing slice "<<slice<<endl;
	182	fBenchmark->Start("ReadData");
	183	hough->ReadData(slice,0);
	184	fBenchmark->Stop("ReadData");
	185	fBenchmark->Start("Transform");
	186	hough->Transform();
	187	fBenchmark->Stop("Transform");
	188	hough->AddAllHistogramsRows();
	189	hough->FindTrackCandidatesRow();
	190	fBenchmark->Start("AddTracks");
	191	hough->AddTracks();
	192	fBenchmark->Stop("AddTracks");
	193
	194	AliL3TrackArray* tracks = (AliL3TrackArray*)hough->GetTracks(0);
	195	n_global_tracks += tracks->GetNTracks();
	196	}
	197	*/
	198	fBenchmark->Stop("Overall timing");
3256212a	199	time.Set();
	200	if (file) fprintf(file, "%s\n", time.AsString());
	201	if (file) fprintf(file, "run: %d event: %d %d\n",
	202	rawReader.GetRunNumber(),
	203	rawReader.GetEventId()[0],
	204	rawReader.GetEventId()[1]);
	205	if (errorCode) fprintf(file, "ERROR: %d\n", errorCode);
	206
a8ffd46b	207	if (file) fprintf(file, "Hough Transformer found %d tracks\n",n_global_tracks);
3256212a	208
a8ffd46b	209	hough1->DoBench("hough1");
	210	hough2->DoBench("hough2");
	211	fBenchmark->Analyze("overall");
	212	if (file) {
	213	FILE* bench = fopen("hough1.dat", "r");
	214	while (bench && !feof(bench)) {
	215	char buffer[256];
	216	if (!fgets(buffer, 256, bench)) break;
	217	fprintf(file, "%s", buffer);
	218	}
	219	fclose(bench);
	220	}
3256212a	221	if (file) {
a8ffd46b	222	FILE* bench = fopen("hough2.dat", "r");
3256212a	223	while (bench && !feof(bench)) {
	224	char buffer[256];
	225	if (!fgets(buffer, 256, bench)) break;
	226	fprintf(file, "%s", buffer);
	227	}
	228	fclose(bench);
a8ffd46b	229	}
	230	if (file) {
	231	FILE* bench = fopen("overall.dat", "r");
	232	while (bench && !feof(bench)) {
	233	char buffer[256];
	234	if (!fgets(buffer, 256, bench)) break;
	235	fprintf(file, "%s", buffer);
	236	}
	237	fclose(bench);
	238	fprintf(file, "\n\n");
04b48a95	239	}
b5279783	240
a8ffd46b	241	delete hough1;
a8ffd46b	242	delete hough2;
3256212a	243	}
a8ffd46b	244	// }
	245
	246	/*
	247	// read run, event, detector, DDL numbers and data size
	248	AliRawReaderDate rawReader(ptr);
	249	time.Set();
	250	printf("\n%s\n", time.AsString());
	251	printf("run: %d event: %d %d\n", rawReader.GetRunNumber(),
	252	rawReader.GetEventId()[0], rawReader.GetEventId()[1]);
	253	while (rawReader.ReadMiniHeader()) {
	254	printf(" detector: %d DDL: %d size: %d\n",
	255	rawReader.GetDetectorID(), rawReader.GetDDLID(),
	256	rawReader.GetDataSize());
04b48a95	257	}
b5279783	258
a8ffd46b	259	*/
a8ffd46b	260
df0f3179	261	gSystem->Sleep(100); // sleep for 0.1 second
b5279783	262	free(ptr);
	263
	264	gSystem->ProcessEvents();
	265	if (file) fflush(file);
a8ffd46b	266
b5279783	267	}
	268
	269	gSystem->RemoveSignalHandler(handler);
	270	if (file) fclose(file);
	271
120b3c73	272	return 0;
	273	}
	274
b5279783	275	#else
120b3c73	276	int main(int /argc/, char** /argv/)
120b3c73	277	{
b5279783	278	::Fatal("main", "this program was compiled without DATE");
b5279783	279
120b3c73	280	return 1;
b5279783	281	}
120b3c73	282	#endif