[u/mrichter/AliRoot.git] / TOF / TOFda.cxx

/*

TOF DA for online calibration

Contact: Chiara.Zampolli@bo.infn.it
         Roberto.Preghenella@bo.infn.it

Run Type: PHYSICS
DA Type: MON
Number of events needed:
Input Files: no input
Output Files: TOFdaHits.root
Event types used: PHYSICS_EVENT

*/

#define FILE_HITS "TOFdaHits.root"
#define FILE_CALIB "TOFdaCalib.root"

// DATE
#include "event.h"
#include "monitor.h"
#include "daqDA.h"

#include <stdio.h>
#include <stdlib.h>

//AliRoot
#include "TROOT.h"
#include "AliTOFRawStream.h"
#include "AliRawReaderDate.h"
#include "AliRawReader.h"
#include "AliDAQ.h"
#include "AliTOFHitData.h"
#include "AliTOFHitDataBuffer.h"
#include "AliTOFDaConfigHandler.h"
#include "AliTOFHitField.h"
#include "AliLog.h"
#include "AliTOFGeometry.h"

//ROOT
#include "TFile.h"
#include "TKey.h"
#include "TH2S.h"
#include "TObject.h"
#include "TMath.h"
#include "TSystem.h"
#include "TROOT.h"
#include "TPluginManager.h"
#include "TSAXParser.h"
#include "TTree.h"

/* Main routine
      Arguments: 
      1- monitoring data source
*/
int 
main(int argc, char **argv) 
{
  
  /* magic line from Rene */
  gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
					"*",
					"TStreamerInfo",
					"RIO",
					"TStreamerInfo()");
  

  /* log start of process */
  printf("TOF DA started\n");  
  
  /* check that we got some arguments = list of files */
  if (argc!=2) {
    printf("Wrong number of arguments\n");
    return -1;
  }

  /*
   * CONFIG
   */
  
  /* retrieve config file */
  int getConfigFile = daqDA_DB_getFile("TOFPhysicsConfig.xml","TOFPhysicsConfig.xml");
  if (getConfigFile != 0){
    printf("Failed to retrieve config file from DB! returning...\n");
    return -1;
  }
  /* parse config file */
  AliTOFDaConfigHandler* tofHandler = new AliTOFDaConfigHandler();
  TSAXParser *parser = new TSAXParser();
  parser->ConnectToHandler("AliTOFDaConfigHandler", tofHandler);  
  if (parser->ParseFile("./TOFPhysicsConfig.xml") != 0) {
    printf("Failed parsing config file! retunring... \n");
    return -1;
  }
  /* setup config params */
  Int_t meanMultiplicity = tofHandler->GetMeanMultiplicity(); /* average expected TOF multiplicity */
  Int_t maxHits = tofHandler->GetMaxHits(); /* max number of hits to be collected */
  printf("current settings:\n");
  printf(" - meanMultiplicity = %d\n", meanMultiplicity);
  printf(" - maxHits          = %d\n", maxHits);
  /* constants */
  const Int_t nChannels = 157248;
  Int_t noiseCheckTrigger = 10; /* first noise check after 10 events */
	 Float_t meanChannelRate = (Float_t)meanMultiplicity / (Float_t)nChannels; /* average expected channel rate (hits/event) */
  Float_t noiseThreshold = 10. * meanChannelRate; /* noise threshold (hits/event) */
  Int_t minNoiseHits = 10; /* min number of channel hits to check noise */
  /* counters and flags */
  Int_t nPhysicsEvents, nCalibEvents, totHits;
  Int_t nChHits[nChannels];
  Bool_t inhibitCollection;
  Bool_t noiseFlag[nChannels];
  /* variables */
  Int_t nhits, ddl, slot, trm, chain, tdc, channel, index, timebin, totbin, deltaBC, l0l1latency, det[5], dummy;
  Float_t noiseHitThreshold;

  /*
   * INIT 
   */

  /* init counters and flags */
  nPhysicsEvents = 0;
  nCalibEvents = 0;
  totHits = 0;
  inhibitCollection = kFALSE;
  for (Int_t ich = 0; ich < nChannels; ich++) {
    nChHits[ich] = 0;
    noiseFlag[ich] = kFALSE;
  }

  /* TOF raw data handling */
  AliTOFRawStream *rawStream = new AliTOFRawStream();
  AliTOFHitDataBuffer *pdb = NULL;
  AliTOFHitData *hit = NULL;
  
  /* open HITS output file */
  TFile *fileOutHits = new TFile(FILE_HITS, "RECREATE"); 
  /* create hit field data structure */
  AliTOFHitField *hitField = new AliTOFHitField();
  /* create temporary tree */
  TTree *tempTree = new TTree("tempTree", "temporary tree");
  tempTree->Branch("hit", "AliTOFHitField", &hitField);
  /* create output tree */
  TTree *outTree = new TTree("hitTree", "hit tree");
  outTree->Branch("hit", "AliTOFHitField", &hitField);

  /* open CALIB output file */
  TFile *fileOutCalib = new TFile(FILE_CALIB, "RECREATE"); 
  /* create calib hit histo */
  TH1F *hCalibHit = new TH1F("hCalibHit", "Calibration events;index;N_{hits}/N_{events}", nChannels, 0., nChannels);

  /*
   * ONLINE MONITOR
   */

  AliLog::SetGlobalLogLevel(AliLog::kFatal);
  struct eventHeaderStruct *event;
  int ret;
  /* define data source : this is argument 1 */  
  ret = monitorSetDataSource(argv[1]);
  if (ret != 0) {
    printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(ret));
    return -1;
  }
  /* declare monitoring program */
  ret = monitorDeclareMp("tofDA");
  if (ret != 0) {
    printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(ret));
    return -1;
  }
  /* define wait event timeout - 1s max */
  monitorSetNowait();
  monitorSetNoWaitNetworkTimeout(1000);

  /* loop over events */
  while (1) {
    
    /* check shutdown condition */
    if (daqDA_checkShutdown()) break;
    
    /*
     * NOISE CHECK
     */

    /* check inhibit collection */
    if (!inhibitCollection) {
      /* check number of events and check noise */
      if (nPhysicsEvents >= noiseCheckTrigger || totHits >= maxHits) {
	noiseHitThreshold = noiseThreshold * nPhysicsEvents;
	printf("noise check triggered after %d events: threshold is %f hits\n", nPhysicsEvents, noiseHitThreshold);
	/* loop over all channels */
	for (Int_t ich = 0; ich < nChannels; ich++) {
	  /* check */
	  if (nChHits[ich] < minNoiseHits || noiseFlag[ich] || nChHits[ich] < noiseHitThreshold) continue;
	  printf("channel %d tagged as noisy (%d hits): disabled\n", ich, nChHits[ich]);
	  noiseFlag[ich] = kTRUE;
	  totHits -= nChHits[ich];
	} /* end of loop over all channels */
	/* set new noise check trigger value */
	noiseCheckTrigger *= 10;
      } /* end of noise check */    
      
      /* inhibit hit collection when maximum number of hits exceeded */
      if (totHits >= maxHits) {
	printf("maximum number of hits exceeded (%d): inhibit hit collection\n", maxHits);
	inhibitCollection = kTRUE;
      }
    }
    
    /*
     * GET EVENT
     */

    /* get next event (blocking call until timeout) */
    ret = monitorGetEventDynamic((void **)&event);
    if (ret == MON_ERR_EOF) {
      printf ("End of File detected\n");
      break; /* end of monitoring file has been reached */
    }
    if (ret != 0) {
      printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(ret));
      break;
    }
    /* retry if got no event */
    if (event==NULL) continue;
    /* check event type */
    if (event->eventType != PHYSICS_EVENT && event->eventType != CALIBRATION_EVENT) continue;
    /* check inhibit collection */
    if (event->eventType == PHYSICS_EVENT && inhibitCollection) continue;
    /* increment number of physics events */
    if (event->eventType == PHYSICS_EVENT) nPhysicsEvents++;
    /* increment number of calib events */
    if (event->eventType == CALIBRATION_EVENT) nCalibEvents++;
    
    /*
     * DECODE EVENT
     */

    /* create raw reader */
    AliRawReader *rawReader = new AliRawReaderDate((void *)event);
    /* setup raw stream */
    rawStream->SetRawReader(rawReader);
    /* reset buffers */
    rawStream->ResetBuffers();
    /* decode */
    rawStream->DecodeDDL(0, AliDAQ::NumberOfDdls("TOF") - 1, 0);

    /*
     * HIT MANIPULATION
     */

    /* loop over DDLs */
    for (Int_t iddl = 0; iddl < AliDAQ::NumberOfDdls("TOF"); iddl++) {
      /* get packed-data buffer */
      pdb = rawStream->GetPackedDataBuffer(iddl);
      nhits = pdb->GetEntries();
      /* loop over hits in buffer */
      for (Int_t ihit = 0; ihit < nhits; ihit++) {
	/* get hit */
	hit = pdb->GetHit(ihit);
	/* get channel info */
	ddl = iddl;
	slot = hit->GetSlotID();
	trm = slot - 3;
	chain = hit->GetChain();
	tdc = hit->GetTDC();
	channel = hit->GetChan();
	/* get index */
	rawStream->EquipmentId2VolumeId(ddl, slot, chain, tdc, channel, det);
	dummy = det[4];
	det[4] = det[3];
	det[3] = dummy;
	/* check valid index */
	if (det[0] < 0 || det[0] > 17 ||
	    det[1] < 0 || det[1] > 5 ||
	    det[2] < 0 || det[2] > 18 ||
	    det[3] < 0 || det[3] > 1 ||
	    det[4] < 0 || det[4] > 47) continue;
	index = AliTOFGeometry::GetIndex(det);

	/* switch event type */
	switch (event->eventType) {

	  /*
	   * PHYSICS EVENT
	   */

	case PHYSICS_EVENT:
	  /* check noise flag */
	  if (noiseFlag[index]) continue;
	  /* increment number of channel hits and total hits */
	  nChHits[index]++;
	  totHits++;
	  /* get signal info */
	  timebin = hit->GetTimeBin();
	  totbin = hit->GetTOTBin();
	  deltaBC = hit->GetDeltaBunchID();
	  l0l1latency = hit->GetL0L1Latency();
	  /* set hit field data */
	  hitField->SetIndex(index);
	  hitField->SetTimeBin(timebin);
	  hitField->SetTOTBin(totbin);
	  hitField->SetDeltaBC(deltaBC);
	  hitField->SetL0L1Latency(l0l1latency);
	  /* fill temp tree */
	  tempTree->Fill();
	  break;

	  /*
	   * CALIBRATION EVENT
	   */

	case CALIBRATION_EVENT:
	  /* fill calib hit histo */
	  hCalibHit->Fill(index);
	  break;
	  
	} /* end of switch event type */
      } /* end of loop over hits in buffer */
    } /* end of loop over DDLs */
    
    /* delete raw reader */
    delete rawReader;
    
  } /* end of loop over events */

  /* final noise check */
  noiseHitThreshold = noiseThreshold * nPhysicsEvents;
  printf("final noise check after %d events: threshold is %f hits\n", nPhysicsEvents, noiseHitThreshold);
  /* loop over all channels */
  for (Int_t ich = 0; ich < nChannels; ich++) {
    /* check */
    if (nChHits[ich] < minNoiseHits || noiseFlag[ich] || nChHits[ich] < noiseHitThreshold) continue;
    printf("channel %d tagged as noisy (%d hits): disabled\n", ich, nChHits[ich]);
    noiseFlag[ich] = kTRUE;
    totHits -= nChHits[ich];
  } /* end of loop over all channels */
  
  /* copy hits into output tree from temp tree */
  printf("copy hits from temporary tree into output tree\n");
  printf("temporary tree contains %d hits\n", (Int_t)tempTree->GetEntries());
  for (Int_t ihit = 0; ihit < tempTree->GetEntries(); ihit++) {
    /* get entry */
    tempTree->GetEntry(ihit);
    /* check noise flag */
    if (noiseFlag[hitField->GetIndex()]) continue;
    /* fill output tree */
    outTree->Fill();
  } /* end of copy hits into output tree from temp tree */
  printf("output tree contains %d hits\n", (Int_t)outTree->GetEntries());

  /* write output tree on HITS file */
  fileOutHits->cd();
  outTree->Write();
  fileOutHits->Close();
  /* export file to FXS */
  if (daqDA_FES_storeFile(FILE_HITS, "HITS"))
    return -2;

  /* scale calib hit histo by number of calib events */
  hCalibHit->Sumw2();
  hCalibHit->Scale(1. / nCalibEvents);
  
  /* write calib hit histo on CALIB file */
  fileOutCalib->cd();
  hCalibHit->Write();
  fileOutCalib->Close();
  /* export file to FXS */
  if (daqDA_FES_storeFile(FILE_CALIB, "CALIB"))
    return -2;

  return 0;
}
Commit	Line	Data
7b81ffe5	1	/*
7b81ffe5	2
cee5b064	3	TOF DA for online calibration
7b81ffe5	4
78c742e3	5	Contact: Chiara.Zampolli@bo.infn.it
104ba366	6	Roberto.Preghenella@bo.infn.it
104ba366	7
78c742e3	8	Run Type: PHYSICS
78c742e3	9	DA Type: MON
104ba366	10	Number of events needed:
	11	Input Files: no input
	12	Output Files: TOFdaHits.root
	13	Event types used: PHYSICS_EVENT
dd635345	14
cee5b064	15	*/
7b81ffe5	16
104ba366	17	#define FILE_HITS "TOFdaHits.root"
016d6ae4	18	#define FILE_CALIB "TOFdaCalib.root"
7b81ffe5	19
cee5b064	20	// DATE
67cb6c02	21	#include "event.h"
	22	#include "monitor.h"
	23	#include "daqDA.h"
	24
	25	#include <stdio.h>
	26	#include <stdlib.h>
7b81ffe5	27
7b81ffe5	28	//AliRoot
104ba366	29	#include "TROOT.h"
	30	#include "AliTOFRawStream.h"
	31	#include "AliRawReaderDate.h"
	32	#include "AliRawReader.h"
	33	#include "AliDAQ.h"
	34	#include "AliTOFHitData.h"
	35	#include "AliTOFHitDataBuffer.h"
	36	#include "AliTOFDaConfigHandler.h"
	37	#include "AliTOFHitField.h"
104ba366	38	#include "AliLog.h"
639d40ea	39	#include "AliTOFGeometry.h"
7b81ffe5	40
7b81ffe5	41	//ROOT
104ba366	42	#include "TFile.h"
	43	#include "TKey.h"
	44	#include "TH2S.h"
	45	#include "TObject.h"
	46	#include "TMath.h"
	47	#include "TSystem.h"
3bc66139	48	#include "TROOT.h"
3bc66139	49	#include "TPluginManager.h"
67cb6c02	50	#include "TSAXParser.h"
104ba366	51	#include "TTree.h"
7b81ffe5	52
	53	/* Main routine
	54	Arguments:
	55	1- monitoring data source
	56	*/
104ba366	57	int
	58	main(int argc, char **argv)
	59	{
	60
3bc66139	61	/* magic line from Rene */
3bc66139	62	gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
104ba366	63	"*",
	64	"TStreamerInfo",
	65	"RIO",
	66	"TStreamerInfo()");
7b81ffe5	67
67cb6c02	68
	69	/* log start of process */
	70	printf("TOF DA started\n");
104ba366	71
67cb6c02	72	/* check that we got some arguments = list of files */
7b81ffe5	73	if (argc!=2) {
	74	printf("Wrong number of arguments\n");
	75	return -1;
	76	}
	77
104ba366	78	/*
	79	* CONFIG
	80	*/
	81
67cb6c02	82	/* retrieve config file */
59f6cc12	83	int getConfigFile = daqDA_DB_getFile("TOFPhysicsConfig.xml","TOFPhysicsConfig.xml");
67cb6c02	84	if (getConfigFile != 0){
	85	printf("Failed to retrieve config file from DB! returning...\n");
	86	return -1;
	87	}
104ba366	88	/* parse config file */
59f6cc12	89	AliTOFDaConfigHandler* tofHandler = new AliTOFDaConfigHandler();
67cb6c02	90	TSAXParser *parser = new TSAXParser();
59f6cc12	91	parser->ConnectToHandler("AliTOFDaConfigHandler", tofHandler);
59f6cc12	92	if (parser->ParseFile("./TOFPhysicsConfig.xml") != 0) {
67cb6c02	93	printf("Failed parsing config file! retunring... \n");
	94	return -1;
	95	}
104ba366	96	/* setup config params */
	97	Int_t meanMultiplicity = tofHandler->GetMeanMultiplicity(); /* average expected TOF multiplicity */
	98	Int_t maxHits = tofHandler->GetMaxHits(); /* max number of hits to be collected */
	99	printf("current settings:\n");
	100	printf(" - meanMultiplicity = %d\n", meanMultiplicity);
	101	printf(" - maxHits = %d\n", maxHits);
	102	/* constants */
	103	const Int_t nChannels = 157248;
	104	Int_t noiseCheckTrigger = 10; /* first noise check after 10 events */
	105	Float_t meanChannelRate = (Float_t)meanMultiplicity / (Float_t)nChannels; /* average expected channel rate (hits/event) */
	106	Float_t noiseThreshold = 10. * meanChannelRate; /* noise threshold (hits/event) */
	107	Int_t minNoiseHits = 10; /* min number of channel hits to check noise */
	108	/* counters and flags */
016d6ae4	109	Int_t nPhysicsEvents, nCalibEvents, totHits;
104ba366	110	Int_t nChHits[nChannels];
016d6ae4	111	Bool_t inhibitCollection;
104ba366	112	Bool_t noiseFlag[nChannels];
104ba366	113	/* variables */
639d40ea	114	Int_t nhits, ddl, slot, trm, chain, tdc, channel, index, timebin, totbin, deltaBC, l0l1latency, det[5], dummy;
104ba366	115	Float_t noiseHitThreshold;
	116
	117	/*
	118	* INIT
	119	*/
	120
	121	/* init counters and flags */
016d6ae4	122	nPhysicsEvents = 0;
016d6ae4	123	nCalibEvents = 0;
104ba366	124	totHits = 0;
016d6ae4	125	inhibitCollection = kFALSE;
104ba366	126	for (Int_t ich = 0; ich < nChannels; ich++) {
104ba366	127	nChHits[ich] = 0;
016d6ae4	128	noiseFlag[ich] = kFALSE;
4fc590b9	129	}
67cb6c02	130
104ba366	131	/* TOF raw data handling */
	132	AliTOFRawStream *rawStream = new AliTOFRawStream();
	133	AliTOFHitDataBuffer *pdb = NULL;
	134	AliTOFHitData *hit = NULL;
67cb6c02	135
016d6ae4	136	/* open HITS output file */
016d6ae4	137	TFile *fileOutHits = new TFile(FILE_HITS, "RECREATE");
104ba366	138	/* create hit field data structure */
	139	AliTOFHitField *hitField = new AliTOFHitField();
	140	/* create temporary tree */
	141	TTree *tempTree = new TTree("tempTree", "temporary tree");
	142	tempTree->Branch("hit", "AliTOFHitField", &hitField);
	143	/* create output tree */
	144	TTree *outTree = new TTree("hitTree", "hit tree");
	145	outTree->Branch("hit", "AliTOFHitField", &hitField);
	146
016d6ae4	147	/* open CALIB output file */
	148	TFile *fileOutCalib = new TFile(FILE_CALIB, "RECREATE");
	149	/* create calib hit histo */
	150	TH1F *hCalibHit = new TH1F("hCalibHit", "Calibration events;index;N_{hits}/N_{events}", nChannels, 0., nChannels);
	151
104ba366	152	/*
	153	* ONLINE MONITOR
	154	*/
	155
	156	AliLog::SetGlobalLogLevel(AliLog::kFatal);
67cb6c02	157	struct eventHeaderStruct *event;
104ba366	158	int ret;
7b81ffe5	159	/* define data source : this is argument 1 */
104ba366	160	ret = monitorSetDataSource(argv[1]);
	161	if (ret != 0) {
	162	printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(ret));
7b81ffe5	163	return -1;
7b81ffe5	164	}
7b81ffe5	165	/* declare monitoring program */
104ba366	166	ret = monitorDeclareMp("tofDA");
	167	if (ret != 0) {
	168	printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(ret));
7b81ffe5	169	return -1;
7b81ffe5	170	}
7b81ffe5	171	/* define wait event timeout - 1s max */
	172	monitorSetNowait();
	173	monitorSetNoWaitNetworkTimeout(1000);
104ba366	174
	175	/* loop over events */
	176	while (1) {
7b81ffe5	177
7b81ffe5	178	/* check shutdown condition */
67cb6c02	179	if (daqDA_checkShutdown()) break;
7b81ffe5	180
104ba366	181	/*
	182	* NOISE CHECK
	183	*/
	184
016d6ae4	185	/* check inhibit collection */
	186	if (!inhibitCollection) {
	187	/* check number of events and check noise */
	188	if (nPhysicsEvents >= noiseCheckTrigger \|\| totHits >= maxHits) {
	189	noiseHitThreshold = noiseThreshold * nPhysicsEvents;
	190	printf("noise check triggered after %d events: threshold is %f hits\n", nPhysicsEvents, noiseHitThreshold);
	191	/* loop over all channels */
	192	for (Int_t ich = 0; ich < nChannels; ich++) {
	193	/* check */
	194	if (nChHits[ich] < minNoiseHits \|\| noiseFlag[ich] \|\| nChHits[ich] < noiseHitThreshold) continue;
	195	printf("channel %d tagged as noisy (%d hits): disabled\n", ich, nChHits[ich]);
	196	noiseFlag[ich] = kTRUE;
	197	totHits -= nChHits[ich];
	198	} /* end of loop over all channels */
	199	/* set new noise check trigger value */
	200	noiseCheckTrigger *= 10;
	201	} /* end of noise check */
	202
	203	/* inhibit hit collection when maximum number of hits exceeded */
	204	if (totHits >= maxHits) {
	205	printf("maximum number of hits exceeded (%d): inhibit hit collection\n", maxHits);
	206	inhibitCollection = kTRUE;
	207	}
104ba366	208	}
	209
	210	/*
	211	* GET EVENT
	212	*/
	213
7b81ffe5	214	/* get next event (blocking call until timeout) */
104ba366	215	ret = monitorGetEventDynamic((void **)&event);
104ba366	216	if (ret == MON_ERR_EOF) {
7b81ffe5	217	printf ("End of File detected\n");
	218	break; /* end of monitoring file has been reached */
	219	}
104ba366	220	if (ret != 0) {
104ba366	221	printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(ret));
7b81ffe5	222	break;
7b81ffe5	223	}
7b81ffe5	224	/* retry if got no event */
67cb6c02	225	if (event==NULL) continue;
104ba366	226	/* check event type */
016d6ae4	227	if (event->eventType != PHYSICS_EVENT && event->eventType != CALIBRATION_EVENT) continue;
	228	/* check inhibit collection */
	229	if (event->eventType == PHYSICS_EVENT && inhibitCollection) continue;
	230	/* increment number of physics events */
	231	if (event->eventType == PHYSICS_EVENT) nPhysicsEvents++;
	232	/* increment number of calib events */
	233	if (event->eventType == CALIBRATION_EVENT) nCalibEvents++;
cee5b064	234
104ba366	235	/*
	236	* DECODE EVENT
	237	*/
	238
	239	/* create raw reader */
	240	AliRawReader rawReader = new AliRawReaderDate((void )event);
	241	/* setup raw stream */
	242	rawStream->SetRawReader(rawReader);
	243	/* reset buffers */
	244	rawStream->ResetBuffers();
	245	/* decode */
	246	rawStream->DecodeDDL(0, AliDAQ::NumberOfDdls("TOF") - 1, 0);
	247
	248	/*
	249	* HIT MANIPULATION
	250	*/
	251
	252	/* loop over DDLs */
	253	for (Int_t iddl = 0; iddl < AliDAQ::NumberOfDdls("TOF"); iddl++) {
	254	/* get packed-data buffer */
	255	pdb = rawStream->GetPackedDataBuffer(iddl);
	256	nhits = pdb->GetEntries();
	257	/* loop over hits in buffer */
	258	for (Int_t ihit = 0; ihit < nhits; ihit++) {
	259	/* get hit */
	260	hit = pdb->GetHit(ihit);
	261	/* get channel info */
	262	ddl = iddl;
	263	slot = hit->GetSlotID();
	264	trm = slot - 3;
	265	chain = hit->GetChain();
	266	tdc = hit->GetTDC();
	267	channel = hit->GetChan();
639d40ea	268	/* get index */
	269	rawStream->EquipmentId2VolumeId(ddl, slot, chain, tdc, channel, det);
	270	dummy = det[4];
	271	det[4] = det[3];
	272	det[3] = dummy;
	273	/* check valid index */
	274	if (det[0] < 0 \|\| det[0] > 17 \|\|
	275	det[1] < 0 \|\| det[1] > 5 \|\|
	276	det[2] < 0 \|\| det[2] > 18 \|\|
	277	det[3] < 0 \|\| det[3] > 1 \|\|
	278	det[4] < 0 \|\| det[4] > 47) continue;
	279	index = AliTOFGeometry::GetIndex(det);
016d6ae4	280
	281	/* switch event type */
	282	switch (event->eventType) {
	283
	284	/*
	285	* PHYSICS EVENT
	286	*/
	287
	288	case PHYSICS_EVENT:
	289	/* check noise flag */
	290	if (noiseFlag[index]) continue;
	291	/* increment number of channel hits and total hits */
	292	nChHits[index]++;
	293	totHits++;
	294	/* get signal info */
	295	timebin = hit->GetTimeBin();
	296	totbin = hit->GetTOTBin();
	297	deltaBC = hit->GetDeltaBunchID();
	298	l0l1latency = hit->GetL0L1Latency();
	299	/* set hit field data */
	300	hitField->SetIndex(index);
	301	hitField->SetTimeBin(timebin);
	302	hitField->SetTOTBin(totbin);
	303	hitField->SetDeltaBC(deltaBC);
	304	hitField->SetL0L1Latency(l0l1latency);
	305	/* fill temp tree */
	306	tempTree->Fill();
	307	break;
	308
	309	/*
	310	* CALIBRATION EVENT
	311	*/
	312
	313	case CALIBRATION_EVENT:
	314	/* fill calib hit histo */
	315	hCalibHit->Fill(index);
	316	break;
	317
	318	} /* end of switch event type */
104ba366	319	} /* end of loop over hits in buffer */
104ba366	320	} /* end of loop over DDLs */
7b81ffe5	321
104ba366	322	/* delete raw reader */
	323	delete rawReader;
	324
	325	} /* end of loop over events */
	326
	327	/* final noise check */
016d6ae4	328	noiseHitThreshold = noiseThreshold * nPhysicsEvents;
016d6ae4	329	printf("final noise check after %d events: threshold is %f hits\n", nPhysicsEvents, noiseHitThreshold);
104ba366	330	/* loop over all channels */
	331	for (Int_t ich = 0; ich < nChannels; ich++) {
	332	/* check */
	333	if (nChHits[ich] < minNoiseHits \|\| noiseFlag[ich] \|\| nChHits[ich] < noiseHitThreshold) continue;
	334	printf("channel %d tagged as noisy (%d hits): disabled\n", ich, nChHits[ich]);
	335	noiseFlag[ich] = kTRUE;
	336	totHits -= nChHits[ich];
	337	} /* end of loop over all channels */
7b81ffe5	338
104ba366	339	/* copy hits into output tree from temp tree */
	340	printf("copy hits from temporary tree into output tree\n");
	341	printf("temporary tree contains %d hits\n", (Int_t)tempTree->GetEntries());
	342	for (Int_t ihit = 0; ihit < tempTree->GetEntries(); ihit++) {
	343	/* get entry */
	344	tempTree->GetEntry(ihit);
	345	/* check noise flag */
	346	if (noiseFlag[hitField->GetIndex()]) continue;
	347	/* fill output tree */
	348	outTree->Fill();
	349	} /* end of copy hits into output tree from temp tree */
	350	printf("output tree contains %d hits\n", (Int_t)outTree->GetEntries());
7b81ffe5	351
016d6ae4	352	/* write output tree on HITS file */
	353	fileOutHits->cd();
	354	outTree->Write();
	355	fileOutHits->Close();
cee5b064	356	/* export file to FXS */
104ba366	357	if (daqDA_FES_storeFile(FILE_HITS, "HITS"))
104ba366	358	return -2;
7b81ffe5	359
016d6ae4	360	/* scale calib hit histo by number of calib events */
	361	hCalibHit->Sumw2();
	362	hCalibHit->Scale(1. / nCalibEvents);
	363
	364	/* write calib hit histo on CALIB file */
	365	fileOutCalib->cd();
	366	hCalibHit->Write();
	367	fileOutCalib->Close();
	368	/* export file to FXS */
	369	if (daqDA_FES_storeFile(FILE_CALIB, "CALIB"))
	370	return -2;
	371
104ba366	372	return 0;
7b81ffe5	373	}