Updated DAs to comply with root known problems
[u/mrichter/AliRoot.git] / ZDC / ZDCPEDESTALda.cxx
1 /*
2
3 This program reads the DAQ data files passed as argument using the monitoring library.
4
5
6 The program reports about its processing progress.
7
8 Messages on stdout are exported to DAQ log system.
9
10 DA for ZDC standalone pedestal runs
11
12 Contact: Chiara.Oppedisano@to.infn.it
13 Link: 
14 Run Type: STANDALONE_PEDESTAL_RUN
15 DA Type: LDC
16 Number of events needed: no constraint (tipically ~10^3)
17 Input Files:  
18 Output Files: ZDCPedestal.dat, ZDCChMapping.dat
19 Trigger Types Used: Standalone Trigger
20
21 */
22 #define PEDDATA_FILE  "ZDCPedestal.dat"
23 #define PEDHISTO_FILE "ZDCPedHisto.root"
24 #define MAPDATA_FILE  "ZDCChMapping.dat"
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <Riostream.h>
29
30 // DATE
31 #include <event.h>
32 #include <monitor.h>
33 #include <daqDA.h>
34
35 //ROOT
36 #include <TROOT.h>
37 #include <TPluginManager.h>
38 #include <TH1F.h>
39 #include <TH2F.h>
40 #include <TProfile.h>
41 #include <TF1.h>
42 #include <TFile.h>
43 #include <TFitter.h>
44 #include "TMinuitMinimizer.h"
45
46 //AliRoot
47 #include <AliRawReaderDate.h>
48 #include <AliRawEventHeaderBase.h>
49 #include <AliZDCRawStream.h>
50
51
52 /* Main routine
53       Arguments: list of DATE raw data files
54 */
55 int main(int argc, char **argv) {
56   
57
58   gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
59                                         "*",
60                                         "TStreamerInfo",
61                                         "RIO",
62                                         "TStreamerInfo()"); 
63
64   TMinuitMinimizer m; 
65   gROOT->GetPluginManager()->AddHandler("ROOT::Math::Minimizer", "Minuit","TMinuitMinimizer",
66       "Minuit", "TMinuitMinimizer(const char *)");
67   TVirtualFitter::SetDefaultFitter("Minuit");
68
69   int status = 0;
70   int const kNChannels = 24;
71
72   /* log start of process */
73   printf("\n ZDC PEDESTAL program started\n");  
74
75   /* check that we got some arguments = list of files */
76   if (argc<2){
77     printf("Wrong number of arguments\n");
78     return -1;
79   }
80
81   // --- Histograms for ADC pedestals 
82   //     [22 signal channels + 2 reference PTMs]  x 2 gain chains
83   //
84   TH1F::AddDirectory(0);
85   //
86   TH1F *hPedhg[kNChannels], *hPedOutOfTimehg[kNChannels];
87   TH2F *hPedCorrhg[kNChannels];
88   TH1F *hPedlg[kNChannels], *hPedOutOfTimelg[kNChannels];
89   TH2F *hPedCorrlg[kNChannels];
90   //
91   char namhist1hg[50], namhist2hg[50], namhist3hg[50];
92   char namhist1lg[50], namhist2lg[50], namhist3lg[50];
93   for(Int_t j=0; j<kNChannels; j++){
94      if(j<=4){ // ZNC
95        sprintf(namhist1hg,"PedZNChg_%d",j);
96        sprintf(namhist2hg,"PedZNChgOutOfTime_%d",j);
97        sprintf(namhist3hg,"PedCorrZNChg_%d",j);
98        //
99        sprintf(namhist1lg,"PedZNClg_%d",j);
100        sprintf(namhist2lg,"PedZNClgOutOfTime_%d",j);
101        sprintf(namhist3lg,"PedCorrZNClg_%d",j);
102      }
103      else if(j>=5 && j<=9){ // ZPC
104        sprintf(namhist1hg,"PedZPChg_%d",j-5);
105        sprintf(namhist2hg,"PedZPChgOutOfTime_%d",j-5);
106        sprintf(namhist3hg,"PedCorrZPChg_%d",j-5);
107        //
108        sprintf(namhist1lg,"PedZPClg_%d",j-5);
109        sprintf(namhist2lg,"PedZPClgOutOfTime_%d",j-5);
110        sprintf(namhist3lg,"PedCorrZPClg_%d",j-5);       
111      }
112      else if(j==10 || j==11){ // ZEM
113        sprintf(namhist1hg,"PedZEMhg_%d",j-10);
114        sprintf(namhist2hg,"PedZEMhgOutOfTime_%d",j-10);
115        sprintf(namhist3hg,"PedCorrZEMhg_%d",j-10);
116        //
117        sprintf(namhist1lg,"PedZEMlg_%d",j-10);
118        sprintf(namhist2lg,"PedZEMlgOutOfTime_%d",j-10);
119        sprintf(namhist3lg,"PedCorrZEMlg_%d",j-10);
120      }
121      else if(j>=12 && j<=16){ // ZNA
122        sprintf(namhist1hg,"PedZNAhg_%d",j-12);
123        sprintf(namhist2hg,"PedZNAhgOutOfTime_%d",j-12);
124        sprintf(namhist3hg,"PedCorrZNAhg_%d",j-12);
125        //
126        sprintf(namhist1lg,"PedZNAlg_%d",j-12);
127        sprintf(namhist2lg,"PedZNAlgOutOfTime_%d",j-12);
128        sprintf(namhist3lg,"PedCorrZNAlg_%d",j-12);
129      }
130      else if(j>=17 && j<=21){ // ZPA
131        sprintf(namhist1hg,"PedZPAhg_%d",j-17);
132        sprintf(namhist2hg,"PedZPAhgOutOfTime_%d",j-17);
133        sprintf(namhist3hg,"PedCorrZPAhg_%d",j-17);
134        //
135        sprintf(namhist1lg,"PedZPAlg_%d",j-17);
136        sprintf(namhist2lg,"PedZPAlgOutOfTime_%d",j-17);
137        sprintf(namhist3lg,"PedCorrZPAlg_%d",j-17);
138      }
139      else if(j==22 || j==24){ //Reference PMs
140        sprintf(namhist1hg,"PedRefhg_%d",j-22);
141        sprintf(namhist2hg,"PedRefhgOutOfTime_%d",j-22);
142        sprintf(namhist3hg,"PedCorrRefhg_%d",j-22);
143        //
144        sprintf(namhist1lg,"PedReflg_%d",j-22);
145        sprintf(namhist2lg,"PedReflgOutOfTime_%d",j-22);
146        sprintf(namhist3lg,"PedCorrReflg_%d",j-22);
147      }
148      // --- High gain chain histos
149      hPedhg[j] = new TH1F(namhist1hg, namhist1hg, 200, 0., 200.);
150      hPedOutOfTimehg[j] = new TH1F(namhist2hg, namhist2hg, 200, 0., 200.);
151      hPedCorrhg[j] = new TH2F(namhist3hg,namhist3hg,100,0.,200.,100,0.,200.);
152      // --- Low gain chain histos
153      hPedlg[j] = new TH1F(namhist1lg, namhist1lg, 100, 0., 1000.);
154      hPedOutOfTimelg[j] = new TH1F(namhist2lg, namhist2lg, 100, 0., 1000.);
155      hPedCorrlg[j] = new TH2F(namhist3lg,namhist3lg,100,0.,1000.,100,0.,1000.);
156   }
157
158
159   /* open result file */
160   FILE *fp=NULL;
161   fp=fopen("./result.txt","w");
162   if (fp==NULL) {
163     printf("Failed to open file\n");
164     return -1;
165   }
166   
167   FILE *mapFile4Shuttle;
168
169   /* report progress */
170   daqDA_progressReport(10);
171
172
173   /* init some counters */
174   int nevents_physics=0;
175   int nevents_total=0;
176
177   /* read the data files */
178   int n;
179   for(n=1;n<argc;n++){
180    
181     status=monitorSetDataSource( argv[n] );
182     if (status!=0) {
183       printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
184       return -1;
185     }
186
187     /* report progress */
188     /* in this example, indexed on the number of files */
189     daqDA_progressReport(10+80*n/argc);
190
191     /* read the file */
192     for(;;) {
193       struct eventHeaderStruct *event;
194       eventTypeType eventT;
195
196       /* get next event */
197       status=monitorGetEventDynamic((void **)&event);
198       if(status==MON_ERR_EOF) break; /* end of monitoring file has been reached */
199       if(status!=0) {
200         printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
201         return -1;
202       }
203
204       /* retry if got no event */
205       if(event==NULL) {
206         break;
207       }
208       
209       // Initalize raw-data reading and decoding
210       AliRawReader *reader = new AliRawReaderDate((void*)event);
211       reader->Select("ZDC");
212       // --- Reading event header
213       //UInt_t evtype = reader->GetType();
214       //printf("\n\t ZDCPEDESTALda -> ev. type %d\n",evtype);
215       //printf("\t ZDCPEDESTALda -> run # %d\n",reader->GetRunNumber());
216       //
217       AliZDCRawStream *rawStreamZDC = new AliZDCRawStream(reader);
218         
219
220       /* use event - here, just write event id to result file */
221       eventT=event->eventType;
222       
223       Int_t ich=0;
224       Int_t adcMod[2*kNChannels], adcCh[2*kNChannels], sigCode[2*kNChannels];
225       Int_t det[2*kNChannels], sec[2*kNChannels];
226       
227       if(eventT==START_OF_DATA){
228                 
229         rawStreamZDC->SetSODReading(kTRUE);
230         
231         // --------------------------------------------------------
232         // --- Writing ascii data file for the Shuttle preprocessor
233         mapFile4Shuttle = fopen(MAPDATA_FILE,"w");
234         if(!rawStreamZDC->Next()) printf(" \t No raw data found!! \n");
235         else{
236           while((rawStreamZDC->Next()) && (ich<2*kNChannels)){
237             if(rawStreamZDC->IsChMapping()){
238               adcMod[ich] = rawStreamZDC->GetADCModFromMap(ich);
239               adcCh[ich] = rawStreamZDC->GetADCChFromMap(ich);
240               sigCode[ich] = rawStreamZDC->GetADCSignFromMap(ich);
241               det[ich] = rawStreamZDC->GetDetectorFromMap(ich);
242               sec[ich] = rawStreamZDC->GetTowerFromMap(ich);
243               //
244               fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n",
245                 ich,adcMod[ich],adcCh[ich],sigCode[ich],det[ich],sec[ich]);
246               //
247               //printf("ZDCPEDESTALda.cxx -> %d mod %d ch %d, code %d det %d, sec %d\n",
248               //   ich,adcMod[ich],adcCh[ich],sigCode[ich],det[ich],sec[ich]);
249               //
250               ich++;
251             }
252           }
253         }
254         fclose(mapFile4Shuttle);
255       }// SOD event
256       
257       if(eventT==PHYSICS_EVENT){
258         // --- Reading data header
259         reader->ReadHeader();
260         const AliRawDataHeader* header = reader->GetDataHeader();
261         if(header){
262          UChar_t message = header->GetAttributes();
263          if(message & 0x20){ // PEDESTAL RUN
264             //printf("\t STANDALONE_PEDESTAL RUN raw data found\n");
265          }
266          else{
267             printf("ZDCPEDESTALda.cxx -> NO STANDALONE_PEDESTAL RUN raw data found\n");
268             return -1;
269          }
270         }
271         else{
272            printf("\t ATTENTION! No Raw Data Header found!!!\n");
273            return -1;
274         }
275         
276         rawStreamZDC->SetSODReading(kTRUE);
277
278         if(!rawStreamZDC->Next()) printf(" \t No raw data found!! \n"); 
279         //
280         // ----- Setting ch. mapping -----
281         for(Int_t jk=0; jk<2*kNChannels; jk++){
282           //printf("ZDCPEDESTALDA.cxx ->  ch.%d mod %d, ch %d, code %d det %d, sec %d\n",
283           //    jk,adcMod[jk],adcCh[jk],sigCode[jk],det[jk],sec[jk]);
284           rawStreamZDC->SetMapADCMod(jk, adcMod[jk]);
285           rawStreamZDC->SetMapADCCh(jk, adcCh[jk]);
286           rawStreamZDC->SetMapADCSig(jk, sigCode[jk]);
287           rawStreamZDC->SetMapDet(jk, det[jk]);
288           rawStreamZDC->SetMapTow(jk, sec[jk]);
289         }
290         //
291         Int_t iraw=0;
292         Int_t RawADChg[kNChannels], RawADCoothg[kNChannels];
293         Int_t RawADClg[kNChannels], RawADCootlg[kNChannels];
294         for(Int_t j=0; j<kNChannels; j++){
295            RawADChg[j]=0; RawADCoothg[j]=0;
296            RawADClg[j]=0; RawADCootlg[j]=0;
297         }
298         //
299         while(rawStreamZDC->Next()){
300          Int_t index=-1;
301          Int_t detector = rawStreamZDC->GetSector(0);
302          Int_t sector = rawStreamZDC->GetSector(1);
303          
304          if(rawStreamZDC->IsADCDataWord() && (detector!=-1)){
305           if(sector!=5){ // Physics signals
306             if(detector==1) index = sector; // *** ZNC
307             else if(detector==2) index = sector+5; // *** ZPC
308             else if(detector==3) index = sector+9; // *** ZEM
309             else if(detector==4) index = sector+12; // *** ZNA
310             else if(detector==5) index = sector+17; // *** ZPA
311           }
312           else{ // Reference PMs
313             index = (detector-1)/3+22;
314           }
315           //
316           if(index==-1) printf("ERROR in ZDCPEDESTALda.cxx -> det %d quad %d res %d index %d \n", 
317             detector,sector,rawStreamZDC->GetADCGain(),index);
318           
319            //
320            if(iraw<2*kNChannels){ // --- In-time pedestals (1st 48 raw data)
321             if(rawStreamZDC->GetADCGain()==0){ 
322               hPedhg[index]->Fill(rawStreamZDC->GetADCValue()); 
323               RawADChg[index] = rawStreamZDC->GetADCValue();
324               //
325               //printf("\t filling histo hPedhg[%d]\n",index);
326             }
327             else{
328               hPedlg[index]->Fill(rawStreamZDC->GetADCValue()); 
329               RawADClg[index] = rawStreamZDC->GetADCValue();
330               //
331               //printf("\t filling histo hPedlg[%d]\n",index);
332             }
333            }
334            else{  // --- Out-of-time pedestals
335             if(rawStreamZDC->GetADCGain()==0){
336               hPedOutOfTimehg[index]->Fill(rawStreamZDC->GetADCValue());
337               RawADCoothg[index] = rawStreamZDC->GetADCValue();
338               //
339               //printf("\t filling histo hPedOutOfTimehg[%d]\n",index);
340             }
341             else{
342               hPedOutOfTimelg[index]->Fill(rawStreamZDC->GetADCValue());
343               RawADCootlg[index] = rawStreamZDC->GetADCValue();
344               //
345               //printf("\t filling histo hPedOutOfTimelg[%d]\n",index);
346             }
347            }
348             iraw++;
349           }//IsADCDataWord()
350           //
351           if(iraw == 4*kNChannels){ // Last ADC channel -> Filling correlation histos
352             for(Int_t k=0; k<kNChannels; k++){
353               hPedCorrhg[k]->Fill(RawADCoothg[k], RawADChg[k]);
354               hPedCorrlg[k]->Fill(RawADCootlg[k], RawADClg[k]);
355             }
356           }
357          }
358          //
359          nevents_physics++;
360          //
361          delete reader;
362          delete rawStreamZDC;
363
364       }//(if PHYSICS_EVENT) 
365       nevents_total++;
366
367       /* free resources */
368       free(event);
369     
370     }
371   }  
372   
373   /* Analysis of the histograms */
374   //
375   FILE *fileShuttle;
376   fileShuttle = fopen(PEDDATA_FILE,"w");
377   //
378   Float_t MeanPed[2*kNChannels], MeanPedWidth[2*kNChannels], 
379         MeanPedOOT[2*kNChannels], MeanPedWidthOOT[2*kNChannels];
380   // --- In-time pedestals
381   TF1 *ADCfunchg[kNChannels];
382   for(Int_t i=0; i<kNChannels; i++){
383      if(hPedhg[i]->GetEntries() == 0){
384        printf("\n WARNING! Empty histos -> ending DA WITHOUT writing output\n\n");
385        return -1;
386      } 
387      hPedhg[i]->Fit("gaus","Q");
388      ADCfunchg[i] = hPedhg[i]->GetFunction("gaus");
389      MeanPed[i] = (Double_t) ADCfunchg[i]->GetParameter(1);
390      MeanPedWidth[i] = (Double_t)  ADCfunchg[i]->GetParameter(2);
391      fprintf(fileShuttle,"\t%f\t%f\n",MeanPed[i],MeanPedWidth[i]);
392      //printf("\t MeanPedhg[%d] = %f\n",i, MeanPed[i]);
393   }
394   TF1 *ADCfunclg[kNChannels];
395   for(Int_t i=0; i<kNChannels; i++){
396      hPedlg[i]->Fit("gaus","Q");
397      ADCfunclg[i] = hPedlg[i]->GetFunction("gaus");
398      MeanPed[i+kNChannels] = (Double_t)  ADCfunclg[i]->GetParameter(1);
399      MeanPedWidth[i+kNChannels] = (Double_t)  ADCfunclg[i]->GetParameter(2);
400      fprintf(fileShuttle,"\t%f\t%f\n",MeanPed[i+kNChannels],MeanPedWidth[i+kNChannels]);
401      //printf("\t MeanPedlg[%d] = %f\n",i+kNChannels, MeanPed[i+kNChannels]);
402   }
403   // --- Out-of-time pedestals
404   TF1 *ADCootfunchg[kNChannels];
405   for(Int_t i=0; i<kNChannels; i++){
406      hPedOutOfTimehg[i]->Fit("gaus","Q");
407      ADCootfunchg[i] = hPedOutOfTimehg[i]->GetFunction("gaus");
408      MeanPedOOT[i] = (Double_t)  ADCootfunchg[i]->GetParameter(1);
409      MeanPedWidthOOT[i] = (Double_t)  ADCootfunchg[i]->GetParameter(2);
410      fprintf(fileShuttle,"\t%f\t%f\n",MeanPedOOT[i],MeanPedWidthOOT[i]);
411      //printf("\t MeanPedOOThg[%d] = %f\n",i, MeanPedOOT[i]);
412   }
413   TF1 *ADCootfunclg[kNChannels];
414   for(Int_t i=0; i<kNChannels; i++){
415      hPedOutOfTimelg[i]->Fit("gaus","Q");
416      ADCootfunclg[i] = hPedOutOfTimelg[i]->GetFunction("gaus");
417      MeanPedOOT[i+kNChannels] = (Double_t)  ADCootfunclg[i]->GetParameter(1);
418      MeanPedWidthOOT[i+kNChannels] = (Double_t)  ADCootfunclg[i]->GetParameter(2);
419      fprintf(fileShuttle,"\t%f\t%f\n",MeanPedOOT[i+kNChannels],MeanPedWidthOOT[i+kNChannels]);
420      //printf("\t MeanPedOOTlg[%d] = %f\n",i+kNChannels, MeanPedOOT[i+kNChannels]);
421   }
422   
423   // --- Correlations
424
425 /*  Float_t CorrCoeff0[2*kNChannels], CorrCoeff1[2*kNChannels];
426   TProfile *hPedCorrProfhg[kNChannels], *hPedCorrProflg[kNChannels];
427   TF1 *ffunchg[kNChannels], *ffunclg[kNChannels];
428   char namhist4[50];
429   for(int i=0;i<kNChannels;i++) {
430      sprintf(namhist4,"ADCHRvsOOT%d_Prof",i);
431      hPedCorrProfhg[i] = hPedCorrhg[i]->ProfileX(namhist4,-1,-1,"S");
432      hPedCorrProfhg[i]->SetName(namhist4);
433      hPedCorrProfhg[i]->Fit("pol1","Q");
434      ffunchg[i] = hPedCorrProfhg[i]->GetFunction("pol1");
435      CorrCoeff0[i] = (Double_t)  ffunchg[i]->GetParameter(0);
436      CorrCoeff1[i] = (Double_t) ffunchg[i]->GetParameter(1);
437      fprintf(fileShuttle,"\t%f\t%f\n",CorrCoeff0[i],CorrCoeff1[i]);
438      //printf("\t CorrCoeff0[%d] = %f, CorrCoeff1[%d] = %f\n",i, CorrCoeff0[i], i, CorrCoeff1[i]);
439   }    
440   for(int i=0;i<kNChannels;i++) {
441      sprintf(namhist4,"ADCLRvsOOT%d_Prof",i);
442      hPedCorrProflg[i] = hPedCorrlg[i]->ProfileX(namhist4,-1,-1,"S");
443      hPedCorrProflg[i]->SetName(namhist4);
444      hPedCorrProflg[i]->Fit("pol1","Q");
445      ffunclg[i] = hPedCorrProflg[i]->GetFunction("pol1");
446      CorrCoeff0[i+kNChannels] =  (Double_t) ffunclg[i]->GetParameter(0);
447      CorrCoeff1[i+kNChannels] =  (Double_t) ffunclg[i]->GetParameter(1);
448      fprintf(fileShuttle,"\t%f\t%f\n",CorrCoeff0[i+kNChannels],CorrCoeff1[i+kNChannels]);
449      //printf("\t CorrCoeff0[%d] = %f, CorrCoeff1[%d] = %f\n",
450      //         i+kNChannels, CorrCoeff0[i+kNChannels], i+kNChannels, CorrCoeff1[i+kNChannels]);
451   }    
452 */
453   //                                                   
454   fclose(fileShuttle);
455   //
456   /* report progress */
457   daqDA_progressReport(80);
458   //
459   TFile *histofile = new TFile(PEDHISTO_FILE,"RECREATE");
460   histofile->cd();
461   for(int k=0; k<kNChannels; k++){
462      hPedhg[k]->Write();
463      hPedOutOfTimehg[k]->Write();
464      hPedCorrhg[k]->Write();
465      hPedlg[k]->Write();
466      hPedOutOfTimelg[k]->Write();
467      hPedCorrlg[k]->Write();
468   }
469   //                                                   
470   histofile->Close();
471   //
472   for(Int_t j=0; j<kNChannels; j++){
473      delete hPedhg[j];
474      delete hPedOutOfTimehg[j];
475      delete hPedCorrhg[j];
476      delete hPedlg[j];
477      delete hPedOutOfTimelg[j];
478      delete hPedCorrlg[j];
479   }
480
481   /* write report */
482   fprintf(fp,"Run #%s, received %d physics events out of %d\n",getenv("DATE_RUN_NUMBER"),nevents_physics,nevents_total);
483
484   /* close result file */
485   fclose(fp);
486   
487   /* report progress */
488   daqDA_progressReport(90);
489
490   /* store the result files on FES */
491   // [1] File with mapping
492   status = daqDA_FES_storeFile(MAPDATA_FILE,MAPDATA_FILE);
493   if(status){
494     printf("Failed to export mapping data file to DAQ FES\n");
495     return -1;
496   }
497   // [2] File with pedestal data
498   status = daqDA_FES_storeFile(PEDDATA_FILE,PEDDATA_FILE);
499   if(status){
500     printf("Failed to export pedestal data file to DAQ FES\n");
501     return -1;
502   }
503   // [3] File with pedestal histos
504   status = daqDA_FES_storeFile(PEDHISTO_FILE,PEDHISTO_FILE);
505   if(status){
506     printf("Failed to export pedestal histos file to DAQ FES\n");
507     return -1;
508   }
509   
510   /* store the result files on DB */
511   status = daqDA_DB_storeFile(PEDDATA_FILE,PEDDATA_FILE);  
512   if(status){
513     printf("Failed to store pedestal data file to DAQ DB\n");
514     return -1;
515   }
516
517   /* report progress */
518   daqDA_progressReport(100);
519
520   return status;
521 }