[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 ADCmean_Off[128];
  Double_t ADCsigma_Off[128];
  Double_t PEDmean_Off[128];
  Double_t PEDsigma_Off[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
  
  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;  
  } else {
      /* open the config file and retrieve cuts */
      FILE *fpConfig = fopen("V00DA.config","r");
      int res = fscanf(fpConfig,"%d %d %d %d ",&kClockMin,&kClockMax,&kLowCut,&kHighCut);
      if(res!=4) {
	    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; 
      }
      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 nevents_physics=0;
  int nevents_total=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:
           nevents_physics++;
 	     		 
	   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=kClockMin; j <= kClockMax; 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 -
		   for(Int_t j=kClockMin;j <= kClockMax;j++){
		       Int_t Integrator = rawStream->GetIntegratorFlag(i,j);
		       Float_t pedestal = (float)(rawStream->GetPedestal(i,j));
		       hPEDname[i + 64 * Integrator]->Fill(pedestal);
		   }	
		} 
		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);
		}   			   
             } 
	   }   
           delete rawStream;
           rawStream = 0x0;      
           delete rawReader;
           rawReader = 0x0;	     	 						         
      } // end of switch on event type 
	
      nevents_total++;
      /* 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",nevents_physics);
    
//___________________________________________________________________________
//  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);     
          PEDmean_Off[j]  = PEDmean[i];
          PEDsigma_Off[j] = PEDsigma[i];
          ADCmean_Off[j]  = ADCmean[i];
          ADCsigma_Off[j] = ADCsigma[i]; }
      else{
          Int_t j = GetOfflineChannel(i-64);     
          PEDmean_Off[j+64]  = PEDmean[i];
          PEDsigma_Off[j+64] = PEDsigma[i];
          ADCmean_Off[j+64]  = ADCmean[i];
          ADCsigma_Off[j+64] = ADCsigma[i];
      }
  }
  
  for(Int_t j=0; j<128; j++) {
//      printf(" j = %d, %.3f %.3f %.3f %.3f\n",j,PEDmean_Off[j],PEDsigma_Off[j],
//                                                ADCmean_Off[j],ADCsigma_Off[j]);
      fprintf(fp," %.3f %.3f %.3f %.3f\n",PEDmean_Off[j],PEDsigma_Off[j],
                                          ADCmean_Off[j],ADCsigma_Off[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 ADCmean_Off[128];
	78	Double_t ADCsigma_Off[128];
	79	Double_t PEDmean_Off[128];
	80	Double_t PEDsigma_Off[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
	90	status = daqDA_DB_getFile("V00DA.config","./V00DA.config");
	91	if (status) {
	92	printf("Failed to get Config file (V00DA.config) from DAQ DB, status=%d\n", status);
	93	printf("Take default values of parameters for pedestal calculation \n");
	94	kClockMin = 16;
	95	kClockMax = 19;
	96	kLowCut = 60;
	97	kHighCut = 50;
	98	} else {
	99	/* open the config file and retrieve cuts */
	100	FILE *fpConfig = fopen("V00DA.config","r");
	101	int res = fscanf(fpConfig,"%d %d %d %d ",&kClockMin,&kClockMax,&kLowCut,&kHighCut);
	102	if(res!=4) {
	103	printf("Failed to get values from Config file (V00DA.config): wrong file format - 4 integers are expected - \n");
	104	kClockMin = 16;
	105	kClockMax = 19;
	106	kLowCut = 60;
	107	kHighCut = 50;
	108	}
	109	fclose(fpConfig);
	110	}
	111
	112	printf("LHC Clock Min for pedestal calculation = %d; LHC Clock Max for pedestal calculation = %d; LowCut on signal = %d ; HighCut on pedestal = %d\n",
	113	kClockMin, kClockMax, kLowCut, kHighCut);
	114
	115	//___________________________________________________
	116	// Book HISTOGRAMS - dynamics of p-p collisions -
	117
	118	char ADCname[6];
	119	char PEDname[6];
	120	TH1F *hADCname[128];
	121	TH1F *hPEDname[128];
	122
	123	char texte[12];
	124	for (Int_t i=0; i<128; i++) {
	125	sprintf(ADCname,"hADC%d",i);
	126	sprintf(texte,"ADC cell%d",i);
	127	hADCname[i] = new TH1F(ADCname,texte,1024,-0.5, 1023.5);
	128	sprintf(PEDname,"hPED%d",i);
	129	sprintf(texte,"PED cell%d",i);
	130	hPEDname[i] = new TH1F(PEDname,texte,1024,-0.5, 1023.5);
	131	}
	132	//___________________________________________________
	133
	134	/* open result file to be exported to FES */
	135	FILE *fpLocal=NULL;
	136	fpLocal=fopen("./V0_Pedestals.dat","w");
	137	if (fpLocal==NULL) {
	138	printf("Failed to open local result file\n");
	139	return -1;}
	140
	141	/* open result file to be exported to FES */
	142	FILE *fp=NULL;
	143	fp=fopen("./V0_Ped_Width_Gain.dat","w");
	144	if (fp==NULL) {
	145	printf("Failed to open result file\n");
	146	return -1;}
	147
	148	/* define data source : this is argument 1 */
	149	status=monitorSetDataSource( argv[1] );
	150	if (status!=0) {
	151	printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
	152	return -1;
	153	}
	154
	155	/* declare monitoring program */
	156	status=monitorDeclareMp( __FILE__ );
	157	if (status!=0) {
	158	printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
	159	return -1;
	160	}
	161
	162	/* define wait event timeout - 1s max */
	163	monitorSetNowait();
	164	monitorSetNoWaitNetworkTimeout(1000);
	165
	166	/* init counters on events */
	167	int nevents_physics=0;
	168	int nevents_total=0;
	169
	170	/* loop on events (infinite) */
	171	for(;;) {
	172	struct eventHeaderStruct *event;
	173	eventTypeType eventT;
	174
	175	/* check shutdown condition */
	176	if (daqDA_checkShutdown()) {break;}
	177
	178	/* get next event (blocking call until timeout) */
	179	status=monitorGetEventDynamic((void **)&event);
	180	if (status==MON_ERR_EOF) {
	181	printf ("End of File detected\n");
	182	break; /* end of monitoring file has been reached */
	183	}
	184
	185	if (status!=0) {
	186	printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
	187	break;
	188	}
	189
	190	/* retry if got no event */
	191	if (event==NULL) continue;
	192
	193	/* decode event */
	194	eventT=event->eventType;
	195
	196	switch (event->eventType){
	197
	198	case START_OF_RUN:
	199	break;
	200
	201	case END_OF_RUN:
	202	printf("End Of Run detected\n");
	203	break;
	204
	205	case PHYSICS_EVENT:
	206	nevents_physics++;
	207
	208	AliRawReader rawReader = new AliRawReaderDate((void)event);
	209
	210	AliVZERORawStream* rawStream = new AliVZERORawStream(rawReader);
	211	if (rawStream->Next()) {
	212	for(Int_t i=0; i<64; i++) {
	213	Int_t nFlag = 0;
	214	for(Int_t j=kClockMin; j <= kClockMax; j++) { // Check flags on clock range used for pedestal calculation
	215	if((rawStream->GetBBFlag(i,j)) \|\| (rawStream->GetBGFlag(i,j))) nFlag++;
	216	}
	217	if(nFlag == 0){ // Fill 64*2 pedestal histograms - 2 integrators -
	218	for(Int_t j=kClockMin;j <= kClockMax;j++){
	219	Int_t Integrator = rawStream->GetIntegratorFlag(i,j);
	220	Float_t pedestal = (float)(rawStream->GetPedestal(i,j));
	221	hPEDname[i + 64 * Integrator]->Fill(pedestal);
	222	}
	223	}
	224	if((rawStream->GetBBFlag(i,10)) \|\| (rawStream->GetBGFlag(i,10))){ // Charge
	225	Int_t Integrator = rawStream->GetIntegratorFlag(i,10);
	226	Float_t charge = (float)(rawStream->GetADC(i)); // Fill 64*2 ADCmax histograms
	227	hADCname[i + 64 * Integrator]->Fill(charge);
	228	}
	229	}
	230	}
	231	delete rawStream;
	232	rawStream = 0x0;
	233	delete rawReader;
	234	rawReader = 0x0;
	235	} // end of switch on event type
	236
	237	nevents_total++;
	238	/* free resources */
	239	free(event);
	240
	241	/* exit when last event received, no need to wait for TERM signal */
	242	if (eventT==END_OF_RUN) {
	243	printf("End Of Run event detected\n");
	244	break;
	245	}
	246
	247	} // loop over events
	248
	249	printf("%d physics events processed\n",nevents_physics);
	250
	251	//___________________________________________________________________________
	252	// Computes mean values, converts FEE channels into Offline AliRoot channels
	253	// and dumps the ordered values into the output text file for SHUTTLE
	254
	255	for(Int_t i=0; i<128; i++) {
	256	hPEDname[i]->GetXaxis()->SetRange(0,kHighCut);
	257	PEDmean[i] = hPEDname[i]->GetMean();
	258	PEDsigma[i] = hPEDname[i]->GetRMS();
	259	hADCname[i]->GetXaxis()->SetRange(kLowCut,1024);
	260	ADCmean[i] = hADCname[i]->GetMean();
	261	ADCsigma[i] = hADCname[i]->GetRMS();
	262	// printf(" i = %d, %.3f %.3f %.3f %.3f\n",i,PEDmean[i],PEDsigma[i],ADCmean[i],ADCsigma[i]);
	263	fprintf(fpLocal," %.3f %.3f %.3f %.3f\n",PEDmean[i],PEDsigma[i],
	264	ADCmean[i],ADCsigma[i]);
	265	if (i < 64) {
	266	Int_t j = GetOfflineChannel(i);
	267	PEDmean_Off[j] = PEDmean[i];
	268	PEDsigma_Off[j] = PEDsigma[i];
	269	ADCmean_Off[j] = ADCmean[i];
	270	ADCsigma_Off[j] = ADCsigma[i]; }
	271	else{
	272	Int_t j = GetOfflineChannel(i-64);
	273	PEDmean_Off[j+64] = PEDmean[i];
	274	PEDsigma_Off[j+64] = PEDsigma[i];
	275	ADCmean_Off[j+64] = ADCmean[i];
	276	ADCsigma_Off[j+64] = ADCsigma[i];
	277	}
	278	}
	279
	280	for(Int_t j=0; j<128; j++) {
	281	// printf(" j = %d, %.3f %.3f %.3f %.3f\n",j,PEDmean_Off[j],PEDsigma_Off[j],
	282	// ADCmean_Off[j],ADCsigma_Off[j]);
	283	fprintf(fp," %.3f %.3f %.3f %.3f\n",PEDmean_Off[j],PEDsigma_Off[j],
	284	ADCmean_Off[j],ADCsigma_Off[j]);
	285	}
	286
	287	//________________________________________________________________________
	288	// Write root file with histos for users further check - just in case -
	289
	290	TFile *histoFile = new TFile("VZERO_histos.root","RECREATE");
	291
	292	for (Int_t i=0; i<128; i++) {
	293	hADCname[i]->GetXaxis()->SetRange(0,1024);
	294	hADCname[i]->Write();
	295	hPEDname[i]->Write(); }
	296
	297	histoFile->Close();
	298	delete histoFile;
	299
	300	//________________________________________________________________________
	301
	302	/* close local result file and FXS result file*/
	303	fclose(fpLocal);
	304	fclose(fp);
	305
	306	/* export result file to FES */
	307	status=daqDA_FES_storeFile("./V0_Ped_Width_Gain.dat","V00da_results");
	308	if (status) {
	309	printf("Failed to export file : %d\n",status);
	310	return -1; }
	311
	312	/* store result file into Online DB */
	313	status=daqDA_DB_storeFile("./V0_Pedestals.dat","V00da_results");
	314	if (status) {
	315	printf("Failed to store file into Online DB: %d\n",status);
	316	return -1; }
	317
	318	return status;
	319	}
	320
	321	Int_t GetOfflineChannel(Int_t channel) {
	322
	323	// Channel mapping Online - Offline:
	324
	325	Int_t fOfflineChannel[64] = {39, 38, 37, 36, 35, 34, 33, 32,
	326	47, 46, 45, 44, 43, 42, 41, 40,
	327	55, 54, 53, 52, 51, 50, 49, 48,
	328	63, 62, 61, 60, 59, 58, 57, 56,
	329	7, 6, 5, 4, 3, 2, 1, 0,
	330	15, 14, 13, 12, 11, 10, 9, 8,
	331	23, 22, 21, 20, 19, 18, 17, 16,
	332	31, 30, 29, 28, 27, 26, 25, 24};
	333	return fOfflineChannel[channel];
	334	}