[u/mrichter/AliRoot.git] / VZERO / VZEROda.cxx

/*********************************************************************************
- Contact:    Brigitte Cheynis     b.cheynis@ipnl.in2p3.fr
- Link:       http
- Raw data test file :          
- Reference run number : 	      
- Run Type:   PHYSICS
- DA Type:    MON
- Number of events needed: >=500
- Input Files:  argument list
- Output Files: local files  VZERO_Histos.root, V0_Pedestals.dat (Online mapping)
                FXS file     V0_Ped_Width_Gain.dat (Offline mapping)
- Trigger types used: PHYSICS_EVENT
**********************************************************************************/

/**********************************************************************************
*                                                                                 *
* VZERO Detector Algorithm used for extracting calibration parameters             *
*                                                                                 *
* This program connects to the DAQ data source passed as argument.                *
* It computes calibration parameters, populates local "./V0_Ped_Width_Gain.dat"   *            
* file, exports it to the FES, and stores it into DAQ DB                          *
* The program exits when being asked to shut down (daqDA_checkshutdown)           *
* or on End of Run event.                                                         *
* We have 128 channels instead of 64 as expected for V0 due to the two sets of    *
* charge integrators which are used by the FEE ...                                *
*                                                                                 *
***********************************************************************************/

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

//AliRoot
#include <AliVZERORawStream.h>
#include <AliRawReaderDate.h>
#include <AliRawReader.h>
#include <AliDAQ.h>

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

//ROOT
#include "TROOT.h"
#include "TPluginManager.h"
#include <TFile.h>
#include <TH1F.h>
#include <TMath.h>

Int_t GetOfflineChannel(Int_t channel);

/* Main routine --- Arguments: monitoring data source */
      
int main(int argc, char **argv) {

/* magic line from Cvetan */
  gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
                    "*",
                    "TStreamerInfo",
                    "RIO",
                    "TStreamerInfo()");
  int status;
  if (argc!=2) {
     printf("Wrong number of arguments\n");
     return -1;
  }
  
  // Online values (using FEE channel numbering), 
  // stored into local V0_Pedestals.dat:
  Double_t adcMean[128];
  Double_t adcSigma[128];
  Double_t pedMean[128];
  Double_t pedSigma[128];
  // Offline values(same but ordered as in aliroot for offliners)
  // stored into V0_Ped_Width_Gain.dat: 
  Double_t adcMeanOff[128];
  Double_t adcSigmaOff[128];
  Double_t pedMeanOff[128];
  Double_t pedSigmaOff[128];
       
//___________________________________________________
// Get cuts from V00DA.config file

  Int_t    kClockMin;   // = 16;   LHC Clock Min for pedestal calculation
  Int_t    kClockMax;   // = 19;   LHC Clock Max for pedestal calculation
  Int_t    kLowCut;     // = 60;   low cut on signal distribution - to be tuned
  Int_t    kHighCut;    // = 50;   high cut on pedestal distribution - to be tuned
  Int_t    kClockMinRef;   // = 16;   LHC Clock Min for Flag checking
  Int_t    kClockMaxRef;   // = 20;   LHC Clock Max for Flag checking
  Float_t  kChi2Max; 		// = 1.  Maximum chi2 

  status = daqDA_DB_getFile("V00DA.config","./V00DA.config");
  if (status) {
      printf("Failed to get Config file (V00DA.config) from DAQ DB, status=%d\n", status);
      printf("Take default values of parameters for pedestal calculation \n");
      kClockMin  =  16; 
      kClockMax  =  19; 
      kLowCut    =  60;   
      kHighCut   =  50;  
      kClockMinRef  =  16; 
      kClockMaxRef  =  20; 
      kChi2Max		=  1.;
  } else {
      /* open the config file and retrieve cuts */
      FILE *fpConfig = fopen("V00DA.config","r");
      int res = fscanf(fpConfig,"%d %d %d %d %d %d %f",&kClockMin,&kClockMax,&kLowCut,&kHighCut,&kClockMinRef,&kClockMaxRef,&kChi2Max);
      if(res!=7) {
	    printf("Failed to get values from Config file (V00DA.config): wrong file format - 4 integers are expected - \n");
	    kClockMin  =  16; 
        kClockMax  =  19; 
    	kLowCut    =  60;   
        kHighCut   =  50; 
      	kClockMinRef  =  16; 
      	kClockMaxRef  =  20; 
      	kChi2Max	  =  1.;
      }
      fclose(fpConfig);
  }
  
  printf("LHC Clock Min for pedestal calculation = %d; LHC Clock Max for pedestal calculation = %d; LowCut on signal = %d ; HighCut on pedestal = %d\n",
          kClockMin, kClockMax, kLowCut, kHighCut);

//___________________________________________________
// Book HISTOGRAMS - dynamics of p-p collisions -
      
  char     adcName[6]; 
  char     pedName[6]; 
  TH1F     *hADCname[128];
  TH1F     *hPEDname[128];  
  
  char  texte[12];
  for (Int_t i=0; i<128; i++) {
       sprintf(adcName,"hADC%d",i);
       sprintf(texte,"ADC cell%d",i);
       hADCname[i]  = new TH1F(adcName,texte,1024,-0.5, 1023.5);
       sprintf(pedName,"hPED%d",i);
       sprintf(texte,"PED cell%d",i);
       hPEDname[i]  = new TH1F(pedName,texte,1024,-0.5, 1023.5);
  }
//___________________________________________________ 

  /* open result file to be exported to FES */
  FILE *fpLocal=NULL;
  fpLocal=fopen("./V0_Pedestals.dat","w");
  if (fpLocal==NULL) {
      printf("Failed to open local result file\n");
      return -1;}
   
  /* open result file to be exported to FES */
  FILE *fp=NULL;
  fp=fopen("./V0_Ped_Width_Gain.dat","w");
  if (fp==NULL) {
      printf("Failed to open result file\n");
      return -1;}

  /* define data source : this is argument 1 */  
  status=monitorSetDataSource( argv[1] );
  if (status!=0) {
     printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
     return -1;
  }

  /* declare monitoring program */
  status=monitorDeclareMp( __FILE__ );
  if (status!=0) {
    printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
    return -1;
  }

  /* define wait event timeout - 1s max */
  monitorSetNowait();
  monitorSetNoWaitNetworkTimeout(1000);
  
  /* init counters on events */
  int neventsPhysics=0;
  int neventsTotal=0;

  /* loop on events (infinite) */
  for(;;) {
      struct eventHeaderStruct *event;
      eventTypeType eventT;

      /* check shutdown condition */
      if (daqDA_checkShutdown()) {break;}   

      /* get next event (blocking call until timeout) */
      status=monitorGetEventDynamic((void **)&event);
      if (status==MON_ERR_EOF) {
          printf ("End of File detected\n");
      break; /* end of monitoring file has been reached */
      }
    
      if (status!=0) {
           printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
      break;
      }

      /* retry if got no event */
      if (event==NULL) continue;
               
      /* decode event */
      eventT=event->eventType;
	
      switch (event->eventType){
      
      case START_OF_RUN:
           break;
      
      case END_OF_RUN:
           printf("End Of Run detected\n");
           break;
      
      case PHYSICS_EVENT:
           neventsPhysics++;
 	     		 
	   AliRawReader *rawReader = new AliRawReaderDate((void*)event);
  
	   AliVZERORawStream* rawStream  = new AliVZERORawStream(rawReader); 
	   if (rawStream->Next()) {	
           for(Int_t i=0; i<64; i++) {
	   		Int_t nFlag = 0;
			for(Int_t j=kClockMinRef; j <= kClockMaxRef; j++) {  // Check flags on clock range used for pedestal calculation
		   		if((rawStream->GetBBFlag(i,j)) || (rawStream->GetBGFlag(i,j))) nFlag++; 
			}
			if(nFlag == 0){       // Fill 64*2 pedestal histograms  - 2 integrators -
				Float_t sum[2] = {0.,0.};
				Float_t sumwi[2] = {0.,0.};
		   		for(Int_t j=kClockMin;j <= kClockMax;j++){
		       		Int_t integrator = rawStream->GetIntegratorFlag(i,j);
		       		Float_t pedestal = (float)(rawStream->GetPedestal(i,j));
		       		sum[integrator] += pedestal;
		   			sumwi[integrator] += 1.;
		   		}	
		   		Float_t mean[2] =  {0.,0.};
		   		Float_t chi2[2] =  {0.,0.};
	   			
	   			for(int ii=0;ii<2;ii++) if(sumwi[ii]>1.e-6) mean[ii] = sum[ii] / sumwi[ii];

				for(Int_t j=kClockMin;j <= kClockMax;j++){
		       		Int_t integrator = rawStream->GetIntegratorFlag(i,j);
		       		Float_t pedestal = (float)(rawStream->GetPedestal(i,j));
		   			chi2[integrator] += (mean[integrator] - pedestal) * (mean[integrator] - pedestal);
	   			}	
	   			if(chi2[0]<kChi2Max && chi2[1]<kChi2Max) {
					for(int ii=0;ii<2;ii++){
						if(mean[ii] >1.e-6) hPEDname[i + 64*ii]->Fill(mean[ii]);
					}
				}

			} 
			if((rawStream->GetBBFlag(i,10)) || (rawStream->GetBGFlag(i,10))){ // Charge
		    	Int_t integrator = rawStream->GetIntegratorFlag(i,10);
		    	Float_t charge = (float)(rawStream->GetADC(i));   // Fill 64*2 ADCmax histograms 
		    	hADCname[i + 64 * integrator]->Fill(charge);
			}   			   
    	} // End loop over channels
	   }   // End : if rawstream
           delete rawStream;
           rawStream = 0x0;      
           delete rawReader;
           rawReader = 0x0;	     	 						         
      } // end of switch on event type 
	
      neventsTotal++;
      /* free resources */
      free(event);
	
      /* exit when last event received, no need to wait for TERM signal */
      if (eventT==END_OF_RUN) {
           printf("End Of Run event detected\n");
      break;
    }

  }  // loop over events
  
  printf("%d physics events processed\n",neventsPhysics);
    
//___________________________________________________________________________
//  Computes mean values, converts FEE channels into Offline AliRoot channels
//  and dumps the ordered values into the output text file for SHUTTLE
	
  for(Int_t i=0; i<128; i++) {
      hPEDname[i]->GetXaxis()->SetRange(0,kHighCut);
      pedMean[i]  = hPEDname[i]->GetMean(); 
      pedSigma[i] = hPEDname[i]->GetRMS(); 
      hADCname[i]->GetXaxis()->SetRange(kLowCut,1024);
      adcMean[i]  = hADCname[i]->GetMean();
      adcSigma[i] = hADCname[i]->GetRMS(); 
//      printf(" i = %d, %.3f %.3f %.3f %.3f\n",i,pedMean[i],pedSigma[i],adcMean[i],adcSigma[i]);
      fprintf(fpLocal," %.3f %.3f %.3f %.3f\n",pedMean[i],pedSigma[i],
                                               adcMean[i],adcSigma[i]);
      if (i < 64) {
          Int_t j = GetOfflineChannel(i);     
          pedMeanOff[j]  = pedMean[i];
          pedSigmaOff[j] = pedSigma[i];
          adcMeanOff[j]  = adcMean[i];
          adcSigmaOff[j] = adcSigma[i]; }
      else{
          Int_t j = GetOfflineChannel(i-64);     
          pedMeanOff[j+64]  = pedMean[i];
          pedSigmaOff[j+64] = pedSigma[i];
          adcMeanOff[j+64]  = adcMean[i];
          adcSigmaOff[j+64] = adcSigma[i];
      }
  }
  
  for(Int_t j=0; j<128; j++) {
//      printf(" j = %d, %.3f %.3f %.3f %.3f\n",j,pedMeanOff[j],pedSigmaOff[j],
//                                                adcMeanOff[j],adcSigmaOff[j]);
      fprintf(fp," %.3f %.3f %.3f %.3f\n",pedMeanOff[j],pedSigmaOff[j],
                                          adcMeanOff[j],adcSigmaOff[j]);				       
  }
   
//________________________________________________________________________
// Write root file with histos for users further check - just in case - 

  TFile *histoFile = new TFile("VZERO_histos.root","RECREATE");
    
  for (Int_t i=0; i<128; i++) {
       hADCname[i]->GetXaxis()->SetRange(0,1024);
       hADCname[i]->Write(); 
       hPEDname[i]->Write(); }

  histoFile->Close(); 
  delete histoFile;
  
//________________________________________________________________________
   
  /* close local result file and FXS result file*/
  fclose(fpLocal);
  fclose(fp);
 
  /* export result file to FES */
  status=daqDA_FES_storeFile("./V0_Ped_Width_Gain.dat","V00da_results");
  if (status)    {
      printf("Failed to export file : %d\n",status);
      return -1; }

  /* store result file into Online DB */
  status=daqDA_DB_storeFile("./V0_Pedestals.dat","V00da_results");
  if (status)    {
      printf("Failed to store file into Online DB: %d\n",status);
      return -1; }
      
  return status;
}

 Int_t GetOfflineChannel(Int_t channel) {

// Channel mapping Online - Offline:
 
 Int_t fOfflineChannel[64] = {39, 38, 37, 36, 35, 34, 33, 32, 
                              47, 46, 45, 44, 43, 42, 41, 40, 
			      55, 54, 53, 52, 51, 50, 49, 48, 
			      63, 62, 61, 60, 59, 58, 57, 56,
			       7,  6,  5,  4,  3,  2,  1,  0, 
			      15, 14, 13, 12, 11, 10,  9,  8,
			      23, 22, 21, 20, 19, 18, 17, 16, 
			      31, 30, 29, 28, 27, 26, 25, 24};
 return	fOfflineChannel[channel];		      
}
Commit	Line	Data
	1	/*********************************************************************************
	2	- Contact: Brigitte Cheynis b.cheynis@ipnl.in2p3.fr
	3	- Link: http
	4	- Raw data test file :
	5	- Reference run number :
	6	- Run Type: PHYSICS
	7	- DA Type: MON
	8	- Number of events needed: >=500
	9	- Input Files: argument list
	10	- Output Files: local files VZERO_Histos.root, V0_Pedestals.dat (Online mapping)
	11	FXS file V0_Ped_Width_Gain.dat (Offline mapping)
	12	- Trigger types used: PHYSICS_EVENT
	13	**********************************************************************************/
	14
	15	/**********************************************************************************
	16	* *
	17	* VZERO Detector Algorithm used for extracting calibration parameters *
	18	* *
	19	* This program connects to the DAQ data source passed as argument. *
	20	* It computes calibration parameters, populates local "./V0_Ped_Width_Gain.dat" *
	21	* file, exports it to the FES, and stores it into DAQ DB *
	22	* The program exits when being asked to shut down (daqDA_checkshutdown) *
	23	* or on End of Run event. *
	24	* We have 128 channels instead of 64 as expected for V0 due to the two sets of *
	25	* charge integrators which are used by the FEE ... *
	26	* *
	27	***********************************************************************************/
	28
	29	// DATE
	30	#include "event.h"
	31	#include "monitor.h"
	32	#include "daqDA.h"
	33
	34	//AliRoot
	35	#include <AliVZERORawStream.h>
	36	#include <AliRawReaderDate.h>
	37	#include <AliRawReader.h>
	38	#include <AliDAQ.h>
	39
	40	// standard
	41	#include <stdio.h>
	42	#include <stdlib.h>
	43
	44	//ROOT
	45	#include "TROOT.h"
	46	#include "TPluginManager.h"
	47	#include <TFile.h>
	48	#include <TH1F.h>
	49	#include <TMath.h>
	50
	51	Int_t GetOfflineChannel(Int_t channel);
	52
	53	/* Main routine --- Arguments: monitoring data source */
	54
	55	int main(int argc, char **argv) {
	56
	57	/* magic line from Cvetan */
	58	gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
	59	"*",
	60	"TStreamerInfo",
	61	"RIO",
	62	"TStreamerInfo()");
	63	int status;
	64	if (argc!=2) {
	65	printf("Wrong number of arguments\n");
	66	return -1;
	67	}
	68
	69	// Online values (using FEE channel numbering),
	70	// stored into local V0_Pedestals.dat:
	71	Double_t adcMean[128];
	72	Double_t adcSigma[128];
	73	Double_t pedMean[128];
	74	Double_t pedSigma[128];
	75	// Offline values(same but ordered as in aliroot for offliners)
	76	// stored into V0_Ped_Width_Gain.dat:
	77	Double_t adcMeanOff[128];
	78	Double_t adcSigmaOff[128];
	79	Double_t pedMeanOff[128];
	80	Double_t pedSigmaOff[128];
	81
	82	//___________________________________________________
	83	// Get cuts from V00DA.config file
	84
	85	Int_t kClockMin; // = 16; LHC Clock Min for pedestal calculation
	86	Int_t kClockMax; // = 19; LHC Clock Max for pedestal calculation
	87	Int_t kLowCut; // = 60; low cut on signal distribution - to be tuned
	88	Int_t kHighCut; // = 50; high cut on pedestal distribution - to be tuned
	89	Int_t kClockMinRef; // = 16; LHC Clock Min for Flag checking
	90	Int_t kClockMaxRef; // = 20; LHC Clock Max for Flag checking
	91	Float_t kChi2Max; // = 1. Maximum chi2
	92
	93	status = daqDA_DB_getFile("V00DA.config","./V00DA.config");
	94	if (status) {
	95	printf("Failed to get Config file (V00DA.config) from DAQ DB, status=%d\n", status);
	96	printf("Take default values of parameters for pedestal calculation \n");
	97	kClockMin = 16;
	98	kClockMax = 19;
	99	kLowCut = 60;
	100	kHighCut = 50;
	101	kClockMinRef = 16;
	102	kClockMaxRef = 20;
	103	kChi2Max = 1.;
	104	} else {
	105	/* open the config file and retrieve cuts */
	106	FILE *fpConfig = fopen("V00DA.config","r");
	107	int res = fscanf(fpConfig,"%d %d %d %d %d %d %f",&kClockMin,&kClockMax,&kLowCut,&kHighCut,&kClockMinRef,&kClockMaxRef,&kChi2Max);
	108	if(res!=7) {
	109	printf("Failed to get values from Config file (V00DA.config): wrong file format - 4 integers are expected - \n");
	110	kClockMin = 16;
	111	kClockMax = 19;
	112	kLowCut = 60;
	113	kHighCut = 50;
	114	kClockMinRef = 16;
	115	kClockMaxRef = 20;
	116	kChi2Max = 1.;
	117	}
	118	fclose(fpConfig);
	119	}
	120
	121	printf("LHC Clock Min for pedestal calculation = %d; LHC Clock Max for pedestal calculation = %d; LowCut on signal = %d ; HighCut on pedestal = %d\n",
	122	kClockMin, kClockMax, kLowCut, kHighCut);
	123
	124	//___________________________________________________
	125	// Book HISTOGRAMS - dynamics of p-p collisions -
	126
	127	char adcName[6];
	128	char pedName[6];
	129	TH1F *hADCname[128];
	130	TH1F *hPEDname[128];
	131
	132	char texte[12];
	133	for (Int_t i=0; i<128; i++) {
	134	sprintf(adcName,"hADC%d",i);
	135	sprintf(texte,"ADC cell%d",i);
	136	hADCname[i] = new TH1F(adcName,texte,1024,-0.5, 1023.5);
	137	sprintf(pedName,"hPED%d",i);
	138	sprintf(texte,"PED cell%d",i);
	139	hPEDname[i] = new TH1F(pedName,texte,1024,-0.5, 1023.5);
	140	}
	141	//___________________________________________________
	142
	143	/* open result file to be exported to FES */
	144	FILE *fpLocal=NULL;
	145	fpLocal=fopen("./V0_Pedestals.dat","w");
	146	if (fpLocal==NULL) {
	147	printf("Failed to open local result file\n");
	148	return -1;}
	149
	150	/* open result file to be exported to FES */
	151	FILE *fp=NULL;
	152	fp=fopen("./V0_Ped_Width_Gain.dat","w");
	153	if (fp==NULL) {
	154	printf("Failed to open result file\n");
	155	return -1;}
	156
	157	/* define data source : this is argument 1 */
	158	status=monitorSetDataSource( argv[1] );
	159	if (status!=0) {
	160	printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
	161	return -1;
	162	}
	163
	164	/* declare monitoring program */
	165	status=monitorDeclareMp( __FILE__ );
	166	if (status!=0) {
	167	printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
	168	return -1;
	169	}
	170
	171	/* define wait event timeout - 1s max */
	172	monitorSetNowait();
	173	monitorSetNoWaitNetworkTimeout(1000);
	174
	175	/* init counters on events */
	176	int neventsPhysics=0;
	177	int neventsTotal=0;
	178
	179	/* loop on events (infinite) */
	180	for(;;) {
	181	struct eventHeaderStruct *event;
	182	eventTypeType eventT;
	183
	184	/* check shutdown condition */
	185	if (daqDA_checkShutdown()) {break;}
	186
	187	/* get next event (blocking call until timeout) */
	188	status=monitorGetEventDynamic((void **)&event);
	189	if (status==MON_ERR_EOF) {
	190	printf ("End of File detected\n");
	191	break; /* end of monitoring file has been reached */
	192	}
	193
	194	if (status!=0) {
	195	printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
	196	break;
	197	}
	198
	199	/* retry if got no event */
	200	if (event==NULL) continue;
	201
	202	/* decode event */
	203	eventT=event->eventType;
	204
	205	switch (event->eventType){
	206
	207	case START_OF_RUN:
	208	break;
	209
	210	case END_OF_RUN:
	211	printf("End Of Run detected\n");
	212	break;
	213
	214	case PHYSICS_EVENT:
	215	neventsPhysics++;
	216
	217	AliRawReader rawReader = new AliRawReaderDate((void)event);
	218
	219	AliVZERORawStream* rawStream = new AliVZERORawStream(rawReader);
	220	if (rawStream->Next()) {
	221	for(Int_t i=0; i<64; i++) {
	222	Int_t nFlag = 0;
	223	for(Int_t j=kClockMinRef; j <= kClockMaxRef; j++) { // Check flags on clock range used for pedestal calculation
	224	if((rawStream->GetBBFlag(i,j)) \|\| (rawStream->GetBGFlag(i,j))) nFlag++;
	225	}
	226	if(nFlag == 0){ // Fill 64*2 pedestal histograms - 2 integrators -
	227	Float_t sum[2] = {0.,0.};
	228	Float_t sumwi[2] = {0.,0.};
	229	for(Int_t j=kClockMin;j <= kClockMax;j++){
	230	Int_t integrator = rawStream->GetIntegratorFlag(i,j);
	231	Float_t pedestal = (float)(rawStream->GetPedestal(i,j));
	232	sum[integrator] += pedestal;
	233	sumwi[integrator] += 1.;
	234	}
	235	Float_t mean[2] = {0.,0.};
	236	Float_t chi2[2] = {0.,0.};
	237
	238	for(int ii=0;ii<2;ii++) if(sumwi[ii]>1.e-6) mean[ii] = sum[ii] / sumwi[ii];
	239
	240	for(Int_t j=kClockMin;j <= kClockMax;j++){
	241	Int_t integrator = rawStream->GetIntegratorFlag(i,j);
	242	Float_t pedestal = (float)(rawStream->GetPedestal(i,j));
	243	chi2[integrator] += (mean[integrator] - pedestal) * (mean[integrator] - pedestal);
	244	}
	245	if(chi2[0]<kChi2Max && chi2[1]<kChi2Max) {
	246	for(int ii=0;ii<2;ii++){
	247	if(mean[ii] >1.e-6) hPEDname[i + 64*ii]->Fill(mean[ii]);
	248	}
	249	}
	250
	251	}
	252	if((rawStream->GetBBFlag(i,10)) \|\| (rawStream->GetBGFlag(i,10))){ // Charge
	253	Int_t integrator = rawStream->GetIntegratorFlag(i,10);
	254	Float_t charge = (float)(rawStream->GetADC(i)); // Fill 64*2 ADCmax histograms
	255	hADCname[i + 64 * integrator]->Fill(charge);
	256	}
	257	} // End loop over channels
	258	} // End : if rawstream
	259	delete rawStream;
	260	rawStream = 0x0;
	261	delete rawReader;
	262	rawReader = 0x0;
	263	} // end of switch on event type
	264
	265	neventsTotal++;
	266	/* free resources */
	267	free(event);
	268
	269	/* exit when last event received, no need to wait for TERM signal */
	270	if (eventT==END_OF_RUN) {
	271	printf("End Of Run event detected\n");
	272	break;
	273	}
	274
	275	} // loop over events
	276
	277	printf("%d physics events processed\n",neventsPhysics);
	278
	279	//___________________________________________________________________________
	280	// Computes mean values, converts FEE channels into Offline AliRoot channels
	281	// and dumps the ordered values into the output text file for SHUTTLE
	282
	283	for(Int_t i=0; i<128; i++) {
	284	hPEDname[i]->GetXaxis()->SetRange(0,kHighCut);
	285	pedMean[i] = hPEDname[i]->GetMean();
	286	pedSigma[i] = hPEDname[i]->GetRMS();
	287	hADCname[i]->GetXaxis()->SetRange(kLowCut,1024);
	288	adcMean[i] = hADCname[i]->GetMean();
	289	adcSigma[i] = hADCname[i]->GetRMS();
	290	// printf(" i = %d, %.3f %.3f %.3f %.3f\n",i,pedMean[i],pedSigma[i],adcMean[i],adcSigma[i]);
	291	fprintf(fpLocal," %.3f %.3f %.3f %.3f\n",pedMean[i],pedSigma[i],
	292	adcMean[i],adcSigma[i]);
	293	if (i < 64) {
	294	Int_t j = GetOfflineChannel(i);
	295	pedMeanOff[j] = pedMean[i];
	296	pedSigmaOff[j] = pedSigma[i];
	297	adcMeanOff[j] = adcMean[i];
	298	adcSigmaOff[j] = adcSigma[i]; }
	299	else{
	300	Int_t j = GetOfflineChannel(i-64);
	301	pedMeanOff[j+64] = pedMean[i];
	302	pedSigmaOff[j+64] = pedSigma[i];
	303	adcMeanOff[j+64] = adcMean[i];
	304	adcSigmaOff[j+64] = adcSigma[i];
	305	}
	306	}
	307
	308	for(Int_t j=0; j<128; j++) {
	309	// printf(" j = %d, %.3f %.3f %.3f %.3f\n",j,pedMeanOff[j],pedSigmaOff[j],
	310	// adcMeanOff[j],adcSigmaOff[j]);
	311	fprintf(fp," %.3f %.3f %.3f %.3f\n",pedMeanOff[j],pedSigmaOff[j],
	312	adcMeanOff[j],adcSigmaOff[j]);
	313	}
	314
	315	//________________________________________________________________________
	316	// Write root file with histos for users further check - just in case -
	317
	318	TFile *histoFile = new TFile("VZERO_histos.root","RECREATE");
	319
	320	for (Int_t i=0; i<128; i++) {
	321	hADCname[i]->GetXaxis()->SetRange(0,1024);
	322	hADCname[i]->Write();
	323	hPEDname[i]->Write(); }
	324
	325	histoFile->Close();
	326	delete histoFile;
	327
	328	//________________________________________________________________________
	329
	330	/* close local result file and FXS result file*/
	331	fclose(fpLocal);
	332	fclose(fp);
	333
	334	/* export result file to FES */
	335	status=daqDA_FES_storeFile("./V0_Ped_Width_Gain.dat","V00da_results");
	336	if (status) {
	337	printf("Failed to export file : %d\n",status);
	338	return -1; }
	339
	340	/* store result file into Online DB */
	341	status=daqDA_DB_storeFile("./V0_Pedestals.dat","V00da_results");
	342	if (status) {
	343	printf("Failed to store file into Online DB: %d\n",status);
	344	return -1; }
	345
	346	return status;
	347	}
	348
	349	Int_t GetOfflineChannel(Int_t channel) {
	350
	351	// Channel mapping Online - Offline:
	352
	353	Int_t fOfflineChannel[64] = {39, 38, 37, 36, 35, 34, 33, 32,
	354	47, 46, 45, 44, 43, 42, 41, 40,
	355	55, 54, 53, 52, 51, 50, 49, 48,
	356	63, 62, 61, 60, 59, 58, 57, 56,
	357	7, 6, 5, 4, 3, 2, 1, 0,
	358	15, 14, 13, 12, 11, 10, 9, 8,
	359	23, 22, 21, 20, 19, 18, 17, 16,
	360	31, 30, 29, 28, 27, 26, 25, 24};
	361	return fOfflineChannel[channel];
	362	}