CMake: Changing DA detector name to DA0 to match DAQ settings
[u/mrichter/AliRoot.git] / AD / DA / ADPEDESTALda.cxx
1 /*********************************************************************************
2 - Contact:    Michal Broz     Michal.Broz@cern.ch
3 - Link:       http
4 - Raw data test file :          
5 - Reference run number :              
6 - Run Type:   PEDESTAL
7 - DA Type:    LDC
8 - Number of events needed: >=1000
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
35 #include <AliADConst.h>
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
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 //___________________________________________________
79 // Get cuts from AD0_Pedestal_DA.config file
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");
93       kClockMin  =  0; 
94       kClockMax  =  20; 
95       kLowCut    =  60;   
96       kHighCut   =  50;  
97       kClockMinRef  =  0; 
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");
106             kClockMin  =  0; 
107         kClockMax  =  20; 
108         kLowCut    =  60;   
109         kHighCut   =  50; 
110         kClockMinRef  =  0; 
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) {
292           Int_t j = kOfflineChannel[i];;     
293           pedMeanOff[j]  = pedMean[i];
294           pedSigmaOff[j] = pedSigma[i];
295           adcMeanOff[j]  = adcMean[i];
296           adcSigmaOff[j] = adcSigma[i]; 
297           }
298       else{
299           Int_t j = kOfflineChannel[i-16];     
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 }
347