[u/mrichter/AliRoot.git] / AD / DA / AD0PEDESTALda.cxx

/*********************************************************************************
- Contact:    Michal Broz     Michal.Broz@cern.ch
- Link:       http
- Raw data test file :          
- Reference run number : 	      
- Run Type:   PEDESTAL
- DA Type:    LDC
- Number of events needed: >=1000
- Input Files:  argument list
- Output Files: local files  AD0_Histos.root, AD0_Pedestals_On.dat (Online mapping)
                FXS file     AD0_Pedestals_Off.dat (Offline mapping)
- Trigger types used: PHYSICS_EVENT
**********************************************************************************/

/**********************************************************************************
*                                                                                 *
* AD Detector Algorithm used for extracting calibration parameters             *
*                                                                                 *
* This program connects to the DAQ data source passed as argument.                *
* It computes calibration parameters, populates local "./AD0_Pedestals_On.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 32 channels instead of 16 as expected for AD0 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 <AliADConst.h>
#include <AliADRawStream.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>

/* 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 AD0_Pedestals_On.dat:
  Double_t adcMean[32];
  Double_t adcSigma[32];
  Double_t pedMean[32];
  Double_t pedSigma[32];
  // Offline values(same but ordered as in aliroot for offliners)
  // stored into AD0_Pedestals_Off.dat: 
  Double_t adcMeanOff[32];
  Double_t adcSigmaOff[32];
  Double_t pedMeanOff[32];
  Double_t pedSigmaOff[32];
       
//___________________________________________________
// Get cuts from AD0_Pedestal_DA.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("AD0_Pedestal_DA.config","./AD0_Pedestal_DA.config");
  if (status) {
      printf("Failed to get Config file (AD0_Pedestal_DA.config) from DAQ DB, status=%d\n", status);
      printf("Take default values of parameters for pedestal calculation \n");
      kClockMin  =  0; 
      kClockMax  =  20; 
      kLowCut    =  60;   
      kHighCut   =  50;  
      kClockMinRef  =  0; 
      kClockMaxRef  =  20; 
      kChi2Max		=  100.;
  } else {
      /* open the config file and retrieve cuts */
      FILE *fpConfig = fopen("AD0_Pedestal_DA.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 (AD0_Pedestal_DA.config): wrong file format - 7 integers are expected - \n");
	    kClockMin  =  0; 
        kClockMax  =  20; 
    	kLowCut    =  60;   
        kHighCut   =  50; 
      	kClockMinRef  =  0; 
      	kClockMaxRef  =  20; 
      	kChi2Max	  =  100.;
      }
      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[32];
  TH1F     *hPEDname[32];  
  
  char  texte[12];
  for (Int_t i=0; i<16; i++) {
  	for(Int_t j=0; j<2; j++){
       		sprintf(adcName,"hADC%d%d",i,j);
       		sprintf(texte,"ADC cell%d int%d",i,j);
       		hADCname[i + 16*j]  = new TH1F(adcName,texte,1024,-0.5, 1023.5);
       		sprintf(pedName,"hPED%d%d",i,j);
       		sprintf(texte,"PED cell%d int%d",i,j);
       		hPEDname[i + 16*j]  = new TH1F(pedName,texte,1024,-0.5, 1023.5);
       		}
       }
//___________________________________________________ 

  /* open result file to be exported to FES */
  FILE *fpLocal=NULL;
  fpLocal=fopen("./AD0_Pedestals_On.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("./AD0_Pedestals_Off.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);
  
	   AliADRawStream* rawStream  = new AliADRawStream(rawReader); 
	   if (rawStream->Next()) {	
           for(Int_t i=0; i<16; 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 16*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 + 16*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 16*2 ADCmax histograms 
		    	hADCname[i + 16 * 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<32; 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 < 16) {
          Int_t j = kOfflineChannel[i];;     
          pedMeanOff[j]  = pedMean[i];
          pedSigmaOff[j] = pedSigma[i];
          adcMeanOff[j]  = adcMean[i];
          adcSigmaOff[j] = adcSigma[i]; 
	  }
      else{
          Int_t j = kOfflineChannel[i-16];     
          pedMeanOff[j+16]  = pedMean[i];
          pedSigmaOff[j+16] = pedSigma[i];
          adcMeanOff[j+16]  = adcMean[i];
          adcSigmaOff[j+16] = adcSigma[i];
      }
  }
  
  for(Int_t j=0; j<32; 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("AD0_Pedestals.root","RECREATE");
    
  for (Int_t i=0; i<32; 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("./AD0_Pedestals_Off.dat","AD0da_results");
  if (status)    {
      printf("Failed to export file : %d\n",status);
      return -1; }

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