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