9fdf1dacd09ea2dca65782d555e2ef9a9f6263b2
[u/mrichter/AliRoot.git] / ZDC / ZDCLASERda.cxx
1 /*
2
3 This program reads the DAQ data files passed as argument using the monitoring library.
4
5 The program reports about its processing progress.
6
7 Messages on stdout are exported to DAQ log system.
8
9 DA for ZDC standalone pedestal runs
10
11 Contact: Chiara.Oppedisano@to.infn.it
12 Link: 
13 Run Type: STANDALONE_LASER_RUN
14 DA Type: LDC
15 Number of events needed: no constraint (tipically ~10^3)
16 Input Files: ZDCPedestal.dat
17 Output Files: ZDCLaser.dat
18 Trigger Types Used: Standalone Trigger
19
20 */
21 #define PEDDATA_FILE  "ZDCPedestal.dat"
22 #define MAPDATA_FILE  "ZDCChMapping.dat"
23 #define LASHISTO_FILE "ZDCLaserHisto.root"
24 #define LASDATA_FILE  "ZDCLaserCalib.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 <TF1.h>
40 #include <TFile.h>
41 #include <TFitter.h>
42 #include "TMinuitMinimizer.h"
43
44 //AliRoot
45 #include <AliRawReaderDate.h>
46 #include <AliRawEventHeaderBase.h>
47 #include <AliZDCRawStream.h>
48
49
50 /* Main routine
51       Arguments: list of DATE raw data files
52 */
53 int main(int argc, char **argv) {
54   
55   gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
56                                         "*",
57                                         "TStreamerInfo",
58                                         "RIO",
59                                         "TStreamerInfo()"); 
60
61   TMinuitMinimizer m; 
62   gROOT->GetPluginManager()->AddHandler("ROOT::Math::Minimizer", "Minuit","TMinuitMinimizer",
63       "Minuit", "TMinuitMinimizer(const char *)");
64   TVirtualFitter::SetDefaultFitter("Minuit");
65
66   
67   int status = 0;
68   int const kNModules = 10;
69   int const kNChannels = 24;
70   int const kNScChannels = 32;
71   Int_t kFirstADCGeo=0, kLastADCGeo=1; // NO out-of-time signals!!!
72       
73   Int_t iMod=-1;
74   Int_t modGeo[kNModules], modType[kNModules],modNCh[kNModules];
75   for(Int_t kl=0; kl<kNModules; kl++){
76      modGeo[kl]=modType[kl]=modNCh[kl]=0;
77   }
78   
79   Int_t ich=0;
80   Int_t adcMod[2*kNChannels], adcCh[2*kNChannels], sigCode[2*kNChannels];
81   Int_t det[2*kNChannels], sec[2*kNChannels];
82   for(Int_t y=0; y<2*kNChannels; y++){
83     adcMod[y]=adcCh[y]=sigCode[y]=det[y]=sec[y]=0;
84   }
85   
86   Int_t iScCh=0;
87   Int_t scMod[kNScChannels], scCh[kNScChannels], scSigCode[kNScChannels];
88   Int_t scDet[kNScChannels], scSec[kNScChannels];
89   for(Int_t y=0; y<kNScChannels; y++){
90     scMod[y]=scCh[y]=scSigCode[y]=scDet[y]=scSec[y]=0;
91   }
92
93   /* log start of process */
94   printf("\n ZDC LASER program started\n");  
95
96   /* check that we got some arguments = list of files */
97   if (argc<2) {
98     printf("Wrong number of arguments\n");
99     return -1;
100   }
101
102   // --- Histograms for LASER runs 
103   //     20 signal channels + 2 reference PTMs
104   //
105   TH1F::AddDirectory(0);
106   // --- Histos for reference PMTs (high gain chains)
107   TH1F *hPMRefChg = new TH1F("hPMRefChg","hPMRefChg", 100,-100.5,1100.5);
108   TH1F *hPMRefAhg = new TH1F("hPMRefAhg","hPMRefAhg", 100,-100.5,1100.5);
109   TH1F *hPMRefClg = new TH1F("hPMRefClg","hPMRefClg", 100,-100.5,4900.5);
110   TH1F *hPMRefAlg = new TH1F("hPMRefAlg","hPMRefAlg", 100,-100.5,4900.5);
111   //
112   // --- Histos for detector PMTs 
113   TH1F *hZNChg[5], *hZPChg[5], *hZNAhg[5], *hZPAhg[5], *hZEMhg[2];
114   TH1F *hZNClg[5], *hZPClg[5], *hZNAlg[5], *hZPAlg[5], *hZEMlg[2];
115   char hnamZNChg[20], hnamZPChg[20], hnamZNAhg[20], hnamZPAhg[20];
116   char hnamZNClg[20], hnamZPClg[20], hnamZNAlg[20], hnamZPAlg[20];
117   char hnamZEMhg[20], hnamZEMlg[20];
118   for(Int_t j=0; j<5; j++){
119     sprintf(hnamZNChg,"ZNChg-tow%d",j);
120     sprintf(hnamZPChg,"ZPChg-tow%d",j);
121     sprintf(hnamZNAhg,"ZNAhg-tow%d",j);
122     sprintf(hnamZPAhg,"ZPAhg-tow%d",j);
123     //
124     hZNChg[j] = new TH1F(hnamZNChg, hnamZNChg, 100,-100.5,1100.5);
125     hZPChg[j] = new TH1F(hnamZPChg, hnamZPChg, 100,-100.5,1100.5);
126     hZNAhg[j] = new TH1F(hnamZNAhg, hnamZNAhg, 100,-100.5,1100.5);
127     hZPAhg[j] = new TH1F(hnamZPAhg, hnamZPAhg, 100,-100.5,1100.5);
128     //
129     sprintf(hnamZNClg,"ZNClg-tow%d",j);
130     sprintf(hnamZPClg,"ZPClg-tow%d",j);
131     sprintf(hnamZNAlg,"ZNAlg-tow%d",j);
132     sprintf(hnamZPAlg,"ZPAlg-tow%d",j);
133     //
134     hZNClg[j] = new TH1F(hnamZNClg, hnamZNClg, 100,-100.5,4900.5);
135     hZPClg[j] = new TH1F(hnamZPClg, hnamZPClg, 100,-100.5,4900.5);
136     hZNAlg[j] = new TH1F(hnamZNAlg, hnamZNAlg, 100,-100.5,4900.5);
137     hZPAlg[j] = new TH1F(hnamZPAlg, hnamZPAlg, 100,-100.5,4900.5);
138     //
139     if(j<2){
140       sprintf(hnamZEMhg,"ZEM%dhg",j);
141       sprintf(hnamZEMlg,"ZEM%dlg",j);
142       //
143       hZEMhg[j] = new TH1F(hnamZEMhg, hnamZEMhg, 100,-100.5,1100.5);      
144       hZEMlg[j] = new TH1F(hnamZEMlg, hnamZEMlg, 100,-100.5,4900.5);      
145     }
146   }
147
148   /* open result file */
149   FILE *fp=NULL;
150   fp=fopen("./result.txt","a");
151   if (fp==NULL) {
152     printf("Failed to open file\n");
153     return -1;
154   }
155   /* report progress */
156   daqDA_progressReport(10);
157         
158   // *** To analyze LASER events you MUST have a pedestal data file!!!
159   // *** -> check if a pedestal run has been analyzed
160   int read = 0;
161   read = daqDA_DB_getFile(PEDDATA_FILE, PEDDATA_FILE);
162   if(read){
163     printf("\t ERROR!!! ZDCPedestal.dat file NOT FOUND in DAQ db!!!\n");
164     return -1;
165   }
166   else printf("\t ZDCPedestal.dat file retrieved from DAQ db\n");
167   
168   FILE *filePed = fopen(PEDDATA_FILE,"r");
169   if (filePed==NULL) {
170     printf("\t ERROR!!! Can't open ZDCPedestal.dat file!!!\n");
171     return -1;
172   }
173
174   // 144 = 48 in-time + 48 out-of-time + 48 correlations
175   Float_t readValues[2][6*kNChannels];
176   Float_t MeanPedhg[kNChannels], MeanPedlg[kNChannels];
177   Float_t CorrCoeff0[2*kNChannels], CorrCoeff1[2*kNChannels];
178   // ***************************************************
179   //   Unless we have a narrow correlation to fit we
180   //    don't fit and store in-time vs. out-of-time
181   //    histograms -> mean pedstal subtracted!!!!!!
182   // ***************************************************
183   //
184   for(int jj=0; jj<6*kNChannels; jj++){
185     for(int ii=0; ii<2; ii++){
186        fscanf(filePed,"%f",&readValues[ii][jj]);
187     }
188     if(jj<kNChannels){
189       MeanPedhg[jj] = readValues[0][jj];
190       //printf("\t MeanPedhg[%d] = %1.1f\n",jj, MeanPedhg[jj]);
191     }
192     else if(jj>=kNChannels && jj<2*kNChannels){
193       MeanPedlg[jj-kNChannels] = readValues[0][jj];
194       //printf("\t MeanPedlg[%d] = %1.1f\n",jj-kNChannels, MeanPedlg[jj-kNChannels]);
195     }
196     else if(jj>4*kNChannels){
197       CorrCoeff0[jj-4*kNChannels] = readValues[0][jj]; 
198       CorrCoeff1[jj-4*kNChannels] = readValues[1][jj];;
199     }
200   }
201   
202   FILE *mapFile4Shuttle;
203
204   /* report progress */
205   daqDA_progressReport(20);
206
207
208   /* init some counters */
209   int nevents_physics=0;
210   int nevents_total=0;
211
212   struct eventHeaderStruct *event;
213   eventTypeType eventT;
214
215   /* read the data files */
216   int n;
217   for(n=1;n<argc;n++) {
218    
219     status=monitorSetDataSource( argv[n] );
220     if (status!=0) {
221       printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
222       return -1;
223     }
224
225     /* report progress */
226     /* in this example, indexed on the number of files */
227     daqDA_progressReport(20+70*n/argc);
228
229     /* read the file */
230     for(;;) {
231
232       /* get next event */
233       status=monitorGetEventDynamic((void **)&event);
234       if (status==MON_ERR_EOF) break; /* end of monitoring file has been reached */
235       if (status!=0) {
236         printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
237         return -1;
238       }
239
240       /* retry if got no event */
241       if (event==NULL) {
242         break;
243       }
244
245       // Initalize raw-data reading and decoding
246       AliRawReader *reader = new AliRawReaderDate((void*)event);
247       reader->Select("ZDC");
248       // --- Reading event header
249       //UInt_t evtype = reader->GetType();
250       //printf("\n\t ZDCLASERda -> ev. type %d\n",evtype);
251       //printf("\t ZDCLASERda -> run # %d\n",reader->GetRunNumber());
252       //
253       AliZDCRawStream *rawStreamZDC = new AliZDCRawStream(reader);
254         
255
256       /* use event - here, just write event id to result file */
257       eventT=event->eventType;
258       
259       if(eventT==START_OF_DATA){
260         
261         iMod=-1; ich=0; iScCh=0;
262         
263         rawStreamZDC->SetSODReading(kTRUE);
264         
265         // --------------------------------------------------------
266         // --- Writing ascii data file for the Shuttle preprocessor
267         mapFile4Shuttle = fopen(MAPDATA_FILE,"w");
268         if(!rawStreamZDC->Next()) printf(" \t No raw data found!! \n");
269         else{
270           while((rawStreamZDC->Next())){
271             if(rawStreamZDC->IsHeaderMapping()){ // mapping header
272                iMod++;
273                modGeo[iMod]  = rawStreamZDC->GetADCModule();
274                modType[iMod] = rawStreamZDC->GetModType();
275                modNCh[iMod]  = rawStreamZDC->GetADCNChannels();
276             }
277             if(rawStreamZDC->IsChMapping()){ 
278               if(modType[iMod]==1){ // ADC mapping ----------------------
279                 adcMod[ich]  = rawStreamZDC->GetADCModFromMap(ich);
280                 adcCh[ich]   = rawStreamZDC->GetADCChFromMap(ich);
281                 sigCode[ich] = rawStreamZDC->GetADCSignFromMap(ich);
282                 det[ich]     = rawStreamZDC->GetDetectorFromMap(ich);
283                 sec[ich]     = rawStreamZDC->GetTowerFromMap(ich);
284                 ich++;
285               }
286               else if(modType[iMod]==2){ //VME scaler mapping --------------------
287                 scMod[iScCh]     = rawStreamZDC->GetScalerModFromMap(iScCh);
288                 scCh[iScCh]      = rawStreamZDC->GetScalerChFromMap(iScCh);
289                 scSigCode[iScCh] = rawStreamZDC->GetScalerSignFromMap(iScCh);
290                 scDet[iScCh]     = rawStreamZDC->GetScDetectorFromMap(iScCh);
291                 scSec[iScCh]     = rawStreamZDC->GetScTowerFromMap(iScCh);
292                 iScCh++;
293               }
294             }
295           }
296           // Writing data on output FXS file
297           for(Int_t is=0; is<2*kNChannels; is++){
298              fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n",
299                is,adcMod[is],adcCh[is],sigCode[is],det[is],sec[is]);
300              //printf("  Laser DA -> %d ADC: mod %d ch %d, code %d det %d, sec %d\n",
301              //  is,adcMod[is],adcCh[is],sigCode[is],det[is],sec[is]);
302           }
303           for(Int_t is=0; is<kNScChannels; is++){
304              fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n",
305                is,scMod[is],scCh[is],scSigCode[is],scDet[is],scSec[is]);
306              //printf("  Laser DA -> %d Scaler: mod %d ch %d, code %d det %d, sec %d\n",
307              //  is,scMod[is],scCh[is],scSigCode[is],scDet[is],scSec[is]);
308           }
309           for(Int_t is=0; is<kNModules; is++){
310              fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\n",
311              modGeo[is],modType[is],modNCh[is]);
312              //printf("  Laser DA -> Module mapping: geo %d type %d #ch %d\n",
313              //  modGeo[is],modType[is],modNCh[is]);
314           }
315           
316         }
317         fclose(mapFile4Shuttle);
318       }// SOD event
319
320       else if(eventT==PHYSICS_EVENT){
321         // --- Reading data header
322         reader->ReadHeader();
323         const AliRawDataHeader* header = reader->GetDataHeader();
324         if(header) {
325          UChar_t message = header->GetAttributes();
326          if((message & 0x30) == 0x30){ // DEDICATED LASER RUN
327             //printf("\t STANDALONE_LASER_RUN raw data found\n");
328          }
329          else{
330             printf("ZDCLASERda.cxx -> NO STANDALONE_LASER_RUN raw data found\n");
331             return -1;
332          }
333         }
334         else{
335            printf("\t ATTENTION! No Raw Data Header found!!!\n");
336            return -1;
337         }
338
339         rawStreamZDC->SetSODReading(kTRUE);
340
341         if (!rawStreamZDC->Next()) printf(" \t No raw data found!! \n");
342         //
343         // ----- Setting ch. mapping -----
344         for(Int_t jk=0; jk<2*kNChannels; jk++){
345           rawStreamZDC->SetMapADCMod(jk, adcMod[jk]);
346           rawStreamZDC->SetMapADCCh(jk, adcCh[jk]);
347           rawStreamZDC->SetMapADCSig(jk, sigCode[jk]);
348           rawStreamZDC->SetMapDet(jk, det[jk]);
349           rawStreamZDC->SetMapTow(jk, sec[jk]);
350         }
351         //
352         while(rawStreamZDC->Next()){
353           Int_t index=-1;
354           Int_t detector = rawStreamZDC->GetSector(0);
355           Int_t sector = rawStreamZDC->GetSector(1);
356           
357           if(rawStreamZDC->IsADCDataWord() && !(rawStreamZDC->IsUnderflow()) && 
358              !(rawStreamZDC->IsOverflow()) && detector!=-1 &&
359              rawStreamZDC->GetADCModule()>=kFirstADCGeo && rawStreamZDC->GetADCModule()<=kLastADCGeo){
360             
361             if(sector!=5){ // Physics signals
362               if(detector==1)      index = sector;   // *** ZNC
363               else if(detector==2) index = sector+5; // *** ZPC
364               else if(detector==3) index = sector+9; // *** ZEM
365               else if(detector==4) index = sector+12;// *** ZNA
366               else if(detector==5) index = sector+17;// *** ZPA
367             }
368             else{ // Reference PMs
369               index = (detector-1)/3+22;
370             }
371             //
372             if(index==-1) printf("ERROR in ZDCLASERda.cxx -> det %d quad %d res %d index %d ADC %d\n", 
373               detector, sector, rawStreamZDC->GetADCGain(), index, rawStreamZDC->GetADCValue());
374             
375             Float_t Pedestal=0.;
376             if(rawStreamZDC->GetADCGain()==0)      Pedestal = MeanPedhg[index];
377             else if(rawStreamZDC->GetADCGain()==1) Pedestal = MeanPedlg[index];
378             //
379             Float_t CorrADC = rawStreamZDC->GetADCValue() - Pedestal;
380             //
381             //printf("\tdet %d sec %d res %d index %d ped %1.0f ADCcorr %1.0f\n", 
382             //  detector, sector, rawStreamZDC->GetADCGain(), index, Pedestal,CorrADC);
383             
384             // **** Detector PMs
385             if(sector!=5){
386               if(rawStreamZDC->GetADCGain()==0){ // --- High gain chain ---
387                 // ---- side C
388                 if(detector==1)      hZNChg[sector]->Fill(CorrADC);
389                 else if(detector==2) hZPChg[sector]->Fill(CorrADC);
390                 // ---- side A
391                 else if(detector==4) hZNAhg[sector]->Fill(CorrADC);
392                 else if(detector==5) hZPAhg[sector]->Fill(CorrADC);
393                 // ---- ZEM
394                 /*else if(detector==3){
395                   hZEMhg[sector-1]->Fill(CorrADC);
396                 }*/
397               }
398               else if(rawStreamZDC->GetADCGain()==1){ // --- Low gain chain ---
399                 // ---- side C
400                 if(detector==1)      hZNClg[sector]->Fill(CorrADC);
401                 else if(detector==2) hZPClg[sector]->Fill(CorrADC);
402                 // ---- side A
403                 else if(detector==4) hZNAlg[sector]->Fill(CorrADC);
404                 else if(detector==5) hZPAlg[sector]->Fill(CorrADC);
405                 // ---- ZEM
406                 //else if(detector==3) hZEMlg[sector-1]->Fill(CorrADC);
407               }
408             }
409             // **** Reference PMs
410             else if(sector==5){
411               if(rawStreamZDC->GetADCGain()==0){ // --- High gain chain ---
412                 // ---- PMRef chain side C
413                 if(detector==1) hPMRefChg->Fill(CorrADC);
414                 // ---- PMRef side A
415                 else if(detector==4) hPMRefAhg->Fill(CorrADC);
416               }
417               else if(rawStreamZDC->GetADCGain()==1){ // --- Low gain chain ---
418                 // ---- PMRef chain side C
419                 if(detector==1) hPMRefClg->Fill(CorrADC);
420                 // ---- PMRef side A
421                 else if(detector==4) hPMRefAlg->Fill(CorrADC);
422               }
423             }
424           }//IsADCDataWord()+NOunderflow+NOoverflow
425           //
426          }
427          //
428          nevents_physics++;
429          //
430          delete reader;
431          delete rawStreamZDC;
432
433       }//(if PHYSICS_EVENT) 
434
435       /* exit when last event received, no need to wait for TERM signal */
436       else if(eventT==END_OF_RUN) {
437         printf(" -> EOR event detected\n");
438         break;
439       }
440       
441       
442       nevents_total++;
443     
444     }
445           
446     /* free resources */
447     free(event);
448   }  
449   
450   /* Analysis of the histograms */
451   //
452   Int_t detector[2*kNChannels], quad[2*kNChannels];
453   Int_t maxBin[2*kNChannels], nBin[2*kNChannels];
454   Float_t xMax[2*kNChannels], maxXval[2*kNChannels], xlow[2*kNChannels]; 
455   Float_t mean[2*kNChannels], sigma[2*kNChannels];
456   for(Int_t t=0; t<2*kNChannels; t++){
457     detector[t] = quad[t] = 0;
458     maxBin[t] = nBin[t] = 0;
459     xMax[t] = maxXval[t] = xlow[t] = 0.;
460     mean[t] = sigma[t] = 0.;
461   }
462   TF1 *fun[2*kNChannels];
463   Int_t atLeastOneHisto=0;
464   
465   // ******** High gain chain ********
466   for(Int_t k=0; k<5; k++){
467     // --- ZNC
468     detector[k] = 1;
469     quad[k] = k;
470     maxBin[k] = hZNChg[k]->GetMaximumBin();
471     nBin[k] = (hZNChg[k]->GetXaxis())->GetNbins();
472     xMax[k] = (hZNChg[k]->GetXaxis())->GetXmax();
473     if(nBin[k]!=0) maxXval[k] = maxBin[k]*xMax[k]/nBin[k];
474     if(maxXval[k]-150.<0.) xlow[k]=0.;
475     else xlow[k] = maxXval[k]-150.;
476     // checking if at least one histo is fitted
477     if(hZNChg[k]->GetEntries()!=0 || hZNChg[k]->GetMean()>0){
478       atLeastOneHisto=1;
479       //
480       hZNChg[k]->Fit("gaus","Q","",xlow[k],maxXval[k]+150.);
481       fun[k] = hZNChg[k]->GetFunction("gaus");
482       mean[k]  = (Float_t) (fun[k]->GetParameter(1));
483       sigma[k] = (Float_t) (fun[k]->GetParameter(2));
484     }
485     // --- ZPC
486     detector[k+5] = 2;
487     quad[k+5] = k;
488     maxBin[k+5] = hZPChg[k]->GetMaximumBin();
489     nBin[k+5] = (hZPChg[k]->GetXaxis())->GetNbins();
490     xMax[k+5] = (hZPChg[k]->GetXaxis())->GetXmax();
491     if(nBin[k+5]!=0) maxXval[k+5] = maxBin[k+5]*xMax[k+5]/nBin[k+5];
492     if(maxXval[k+5]-150.<0.) xlow[k+5]=0.;
493     else xlow[k+5] = maxXval[k+5]-150.;
494     if(hZPChg[k]->GetEntries()!=0 || hZPChg[k]->GetMean()>0){
495       atLeastOneHisto=1; 
496       //
497       hZPChg[k]->Fit("gaus","Q","",xlow[k+5],maxXval[k+5]+150.);
498       fun[k+5] = hZPChg[k]->GetFunction("gaus");
499       mean[k+5]  = (Float_t) (fun[k+5]->GetParameter(1));
500       sigma[k+5] = (Float_t) (fun[k+5]->GetParameter(2));
501     }
502     // --- ZEM
503 /*    if(k<2){
504       detector[k+10] = 3;
505       quad[k+10] = k+1;
506       maxBin[k+10] = hZEMhg[k]->GetMaximumBin();
507       nBin[k+10] = (hZEMhg[k]->GetXaxis())->GetNbins();
508       xMax[k+10] = (hZEMhg[k]->GetXaxis())->GetXmax();
509       if(nBin[k+10]!=0) maxXval[k+10] = maxBin[k+10]*xMax[k+10]/nBin[k+10];
510       if(maxXval[k+10]-150.<0.) xlow[k+10]=0.;
511       else xlow[k+10] = maxXval[k+10]-150.;
512       printf("ZEM%d: entries %1.0f mean %1.0f\n",k+1,hZEMhg[k]->GetEntries(),hZEMhg[k]->GetMean());
513       if(hZEMhg[k]->GetEntries()!=0 || hZEMhg[k]->GetMean()>0){
514         atLeastOneHisto=1; 
515         //
516         hZEMhg[k]->Fit("gaus","Q","",xlow[k+10],maxXval[k+10]+150.);
517         fun[k+10] = hZEMhg[k]->GetFunction("gaus");
518         mean[k+10]  = (Float_t) (fun[k+10]->GetParameter(1));
519         sigma[k+10] = (Float_t) (fun[k+10]->GetParameter(2));
520       }
521     }
522 */
523     // --- ZNA
524     detector[k+12] = 4;
525     quad[k+12] = k;
526     maxBin[k+12] = hZNAhg[k]->GetMaximumBin();
527     nBin[k+12] = (hZNAhg[k]->GetXaxis())->GetNbins();
528     xMax[k+12] = (hZNAhg[k]->GetXaxis())->GetXmax();
529     if(nBin[k+12]!=0) maxXval[k+12] = maxBin[k+12]*xMax[k+12]/nBin[k+12];
530     if(maxXval[k+12]-150.<0.) xlow[k+12]=0.;
531     else xlow[k+12] = maxXval[k+12]-150.;
532     if(hZNAhg[k]->GetEntries()!=0 || hZNAhg[k]->GetMean()>0){
533       atLeastOneHisto=1; 
534       //
535       hZNAhg[k]->Fit("gaus","Q","",xlow[k+12],maxXval[k+12]+150.);
536       fun[k+12] = hZNAhg[k]->GetFunction("gaus");
537       mean[k+12]  = (Float_t) (fun[k+12]->GetParameter(1));
538       sigma[k+12] = (Float_t) (fun[k+12]->GetParameter(2));
539     }
540     // --- ZPA
541     detector[k+17] = 4;
542     quad[k+17] = 5;
543     maxBin[k+17] = hZPAhg[k]->GetMaximumBin();
544     nBin[k+17] = (hZPAhg[k]->GetXaxis())->GetNbins();
545     xMax[k+17] = (hZPAhg[k]->GetXaxis())->GetXmax();
546     if(nBin[k+17]!=0) maxXval[k+17] = maxBin[k+17]*xMax[k+17]/nBin[k+17];
547     if(maxXval[k+17]-150.<0.) xlow[k+17]=0.;
548     else xlow[k+17] = maxXval[k+17]-150.;
549     if(hZPAhg[k]->GetEntries()!=0 || hZPAhg[k]->GetMean()>0){
550       atLeastOneHisto=1; 
551       //
552       hZPAhg[k]->Fit("gaus","Q","",xlow[k+17],maxXval[k+17]+150.);
553       fun[k+17] = hZPAhg[k]->GetFunction("gaus");
554       mean[k+17]  = (Float_t) (fun[k+17]->GetParameter(1));
555       sigma[k+17] = (Float_t) (fun[k+17]->GetParameter(2));    
556     }
557   }
558   // ~~~~~~~~ PM Ref side C ~~~~~~~~
559   detector[22] = 1;
560   quad[22] = 5;
561   maxBin[22] = hPMRefChg->GetMaximumBin();
562   nBin[22] = (hPMRefChg->GetXaxis())->GetNbins();
563   xMax[22] = (hPMRefChg->GetXaxis())->GetXmax();
564   if(nBin[22]!=0) maxXval[22] = maxBin[22]*xMax[22]/nBin[22];
565   if(maxXval[22]-150.<0.) xlow[22]=0.;
566   else xlow[22] = maxXval[22]-150.;
567   if(hPMRefChg->GetEntries()!=0){
568     atLeastOneHisto=1; 
569     //
570     hPMRefChg->Fit("gaus","Q","",xlow[22],maxXval[22]+150.);
571     fun[22] = hPMRefChg->GetFunction("gaus");
572     mean[22]  = (Float_t) (fun[22]->GetParameter(1));
573     sigma[22] = (Float_t) (fun[22]->GetParameter(2));
574   }
575   // ~~~~~~~~ PM Ref side A ~~~~~~~~
576   detector[23] = 4;
577   quad[23] = 5;
578   maxBin[23] = hPMRefAhg->GetMaximumBin();
579   nBin[23] = (hPMRefAhg->GetXaxis())->GetNbins();
580   xMax[23] = (hPMRefAhg->GetXaxis())->GetXmax();
581   if(nBin[23]!=0) maxXval[23] = maxBin[23]*xMax[23]/nBin[23];
582   if(maxXval[23]-100.<0.) xlow[23]=0.;
583   else xlow[23] = maxXval[23]-150.;
584   if(hPMRefAhg->GetEntries()!=0){
585     atLeastOneHisto=1; 
586     //
587     hPMRefAhg->Fit("gaus","Q","",xlow[23],maxXval[23]+100.);
588     fun[23] = hPMRefAhg->GetFunction("gaus");
589     mean[23]  = (Float_t) (fun[23]->GetParameter(1));
590     sigma[23] = (Float_t) (fun[23]->GetParameter(2));
591   }
592   
593   // ******** Low gain chain ********
594 /*  Int_t kOffset = 24;
595   for(Int_t k=0; k<5; k++){
596     // --- ZNC
597     detector[k+kOffset] = 1;
598     quad[k+kOffset] = k;
599     maxBin[k+kOffset] = hZNClg[k]->GetMaximumBin();
600     nBin[k+kOffset] = (hZNClg[k]->GetXaxis())->GetNbins();
601     xMax[k+kOffset] = (hZNClg[k]->GetXaxis())->GetXmax();
602     if(nBin[k+kOffset]!=0) maxXval[k+kOffset] = maxBin[k+kOffset]*xMax[k+kOffset]/nBin[k+kOffset];
603     if(maxXval[k+kOffset]-150.<0.) xlow[k+kOffset]=0.;
604     else xlow[k+kOffset] = maxXval[k+kOffset]-150.;
605     if(hZNClg[k]->GetEntries()!=0){
606       atLeastOneHisto=1; 
607       //
608       hZNClg[k]->Fit("gaus","Q","",xlow[k+kOffset],maxXval[k+kOffset]+150.);
609       fun[k+kOffset] = hZNClg[k]->GetFunction("gaus");
610       mean[k+kOffset]  = (Float_t) (fun[k+kOffset]->GetParameter(1));
611       sigma[k+kOffset] = (Float_t) (fun[k+kOffset]->GetParameter(2));
612     }
613     // --- ZPC
614     detector[k+kOffset+5] = 2;
615     quad[k+kOffset+5] = k;
616     maxBin[k+kOffset+5] = hZPClg[k]->GetMaximumBin();
617     nBin[k+kOffset+5] = (hZPClg[k]->GetXaxis())->GetNbins();
618     xMax[k+kOffset+5] = (hZPClg[k]->GetXaxis())->GetXmax();
619     if(nBin[k+kOffset+5]!=0) maxXval[k+kOffset+5] = maxBin[k+kOffset+5]*xMax[k+kOffset+5]/nBin[k+kOffset+5];
620     if(maxXval[k+kOffset+5]-150.<0.) xlow[k+kOffset+5]=0.;
621     else xlow[k+kOffset+5] = maxXval[k+kOffset+5]-150.;
622     if(hZPClg[k]->GetEntries()!=0){
623       atLeastOneHisto=1;  
624       //
625       hZPClg[k]->Fit("gaus","Q","",xlow[k+kOffset+5],maxXval[k+kOffset+5]+150.);
626       fun[k+kOffset+5] = hZPClg[k]->GetFunction("gaus");
627       mean[k+kOffset+5]  = (Float_t) (fun[k+kOffset+5]->GetParameter(1));
628       sigma[k+kOffset+5] = (Float_t) (fun[k+kOffset+5]->GetParameter(2));
629     }
630     // --- ZEM1
631     if(k+kOffset<2){
632       detector[k+kOffset+10] = 3;
633       quad[k+kOffset+10] = k+1;
634       maxBin[k+kOffset+10] = hZEMlg[k]->GetMaximumBin();
635       nBin[k+kOffset+10] = (hZEMlg[k]->GetXaxis())->GetNbins();
636       xMax[k+kOffset+10] = (hZEMlg[k]->GetXaxis())->GetXmax();
637       if(nBin[k+kOffset+10]!=0) maxXval[k+kOffset+10] = maxBin[k+kOffset+10]*xMax[k+kOffset+10]/nBin[k+kOffset+10];
638       if(maxXval[k+kOffset+10]-150.<0.) xlow[k+kOffset+10]=0.;
639       else xlow[k+kOffset+10] = maxXval[k+kOffset+10]-150.;
640       if(hZEMlg[k]->GetEntries()!=0){
641         atLeastOneHisto=1;  
642         //
643         hZEMlg[k]->Fit("gaus","Q","",xlow[k+kOffset+10],maxXval[k+kOffset+10]+150.);
644         fun[k+kOffset+10] = hZEMlg[k]->GetFunction("gaus");
645         mean[k+kOffset+10]  = (Float_t) (fun[k+kOffset+10]->GetParameter(1));
646         sigma[k+kOffset+10] = (Float_t) (fun[k+kOffset+10]->GetParameter(2));
647       }
648     }
649     // --- ZNA
650     detector[k+kOffset+12] = 4;
651     quad[k+kOffset+12] = k;
652     maxBin[k+kOffset+12] = hZNAlg[k]->GetMaximumBin();
653     nBin[k+kOffset+12] = (hZNAlg[k]->GetXaxis())->GetNbins();
654     xMax[k+kOffset+12] = (hZNAlg[k]->GetXaxis())->GetXmax();
655     if(nBin[k+kOffset+12]!=0) maxXval[k+kOffset+12] = maxBin[k+kOffset+12]*xMax[k+kOffset+12]/nBin[k+kOffset+12];
656     if(maxXval[k+kOffset+12]-150.<0.) xlow[k+kOffset+12]=0.;
657     else xlow[k+kOffset+12] = maxXval[k+kOffset+12]-150.;
658     if(hZNAlg[k]->GetEntries()!=0){
659       atLeastOneHisto=1;
660       //
661       hZNAlg[k]->Fit("gaus","Q","",xlow[k+kOffset+12],maxXval[k+kOffset+12]+150.);
662       fun[k+kOffset+12] = hZNAlg[k]->GetFunction("gaus");
663       mean[k+kOffset+12]  = (Float_t) (fun[k+kOffset+12]->GetParameter(1));
664       sigma[k+kOffset+12] = (Float_t) (fun[k+kOffset+12]->GetParameter(2));
665     }
666     // --- ZPA
667     detector[k+kOffset+17] = 5;
668     quad[k+kOffset+17] = k;
669     maxBin[k+kOffset+17] = hZPAlg[k]->GetMaximumBin();
670     nBin[k+kOffset+17] = (hZPAlg[k]->GetXaxis())->GetNbins();
671     xMax[k+kOffset+17] = (hZPAlg[k]->GetXaxis())->GetXmax();
672     if(nBin[k+kOffset+17]!=0) maxXval[k+kOffset+17] = maxBin[k+kOffset+17]*xMax[k+kOffset+17]/nBin[k+kOffset+17];
673     if(maxXval[k+kOffset+17]-150.<0.) xlow[k+kOffset+17]=0.;
674     else xlow[k+kOffset+17] = maxXval[k+kOffset+17]-150.;
675     if(hZPAlg[k]->GetEntries()!=0){
676       atLeastOneHisto=1;  
677       //
678       hZPAlg[k]->Fit("gaus","Q","",xlow[k+kOffset+17],maxXval[k+kOffset+17]+150.);
679       fun[k+kOffset+17] = hZPAlg[k]->GetFunction("gaus");
680       mean[k+kOffset+17]  = (Float_t) (fun[k+kOffset+17]->GetParameter(1));
681       sigma[k+kOffset+17] = (Float_t) (fun[k+kOffset+17]->GetParameter(2)); 
682     }   
683   }
684   // ~~~~~~~~ PM Ref side C ~~~~~~~~
685   detector[46] = 1;
686   quad[46] = 5;
687   maxBin[46] = hPMRefClg->GetMaximumBin();
688   nBin[46] = (hPMRefClg->GetXaxis())->GetNbins();
689   xMax[46] = (hPMRefClg->GetXaxis())->GetXmax();
690   if(nBin[46]!=0) maxXval[46] = maxBin[46]*xMax[46]/nBin[46];
691   if(maxXval[46]-150.<0.) xlow[46]=0.;
692   else xlow[46] = maxXval[46]-150.;
693   if(hPMRefClg->GetEntries()!=0){
694     atLeastOneHisto=1; 
695     //
696     hPMRefClg->Fit("gaus","Q","",xlow[46],maxXval[46]+150.);
697     fun[46] = hPMRefClg->GetFunction("gaus");
698     mean[46]  = (Float_t) (fun[46]->GetParameter(1));
699     sigma[46] = (Float_t) (fun[46]->GetParameter(2));
700   }
701   // ~~~~~~~~ PM Ref side A ~~~~~~~~
702   detector[47] = 4;
703   quad[47] = 5;
704   maxBin[47] = hPMRefAlg->GetMaximumBin();
705   nBin[47] = (hPMRefAlg->GetXaxis())->GetNbins();
706   xMax[47] = (hPMRefAlg->GetXaxis())->GetXmax();
707   if(nBin[47]!=0) maxXval[47] = maxBin[47]*xMax[47]/nBin[47];
708   if(maxXval[47]-100.<0.) xlow[47]=0.;
709   else xlow[47] = maxXval[47]-150.;
710   if(hPMRefAlg->GetEntries()!=0){
711     atLeastOneHisto=1;  
712     //
713     hPMRefAlg->Fit("gaus","Q","",xlow[47],maxXval[47]+100.);
714     fun[47] = hPMRefAlg->GetFunction("gaus");
715     mean[47]  = (Float_t) (fun[47]->GetParameter(1));
716     sigma[47] = (Float_t) (fun[47]->GetParameter(2));
717   }
718 */  
719   if(atLeastOneHisto==0){
720     printf("\n WARNING! Empty LASER histos -> ending DA WITHOUT writing output\n\n");
721     return -1;
722   }
723   FILE *fileShuttle;
724   fileShuttle = fopen(LASDATA_FILE,"w");
725   for(Int_t i=0; i<2*kNChannels; i++){
726     fprintf(fileShuttle,"\t%d\t%d\t%f\t%f\n",detector[i],quad[i],mean[i], sigma[i]); 
727   }
728   //                                                   
729   fclose(fileShuttle);
730     
731   /* report progress */
732   daqDA_progressReport(80);
733   //
734   TFile *histofile = new TFile(LASHISTO_FILE,"RECREATE");
735   histofile->cd();
736   for(int j=0; j<5; j++){
737      hZNChg[j]->Write();
738      hZPChg[j]->Write();
739      hZNAhg[j]->Write();
740      hZPAhg[j]->Write();
741      hZNClg[j]->Write();
742      hZPClg[j]->Write();
743      hZNAlg[j]->Write();
744      hZPAlg[j]->Write();  
745      /*if(j<2){
746        hZEMhg[j]->Write();
747        hZEMlg[j]->Write();
748      }*/
749   }
750   hPMRefChg->Write();
751   hPMRefAhg->Write();
752   hPMRefClg->Write();
753   hPMRefAlg->Write();  
754   //
755   histofile->Close();
756   //
757   for(Int_t j=0; j<5; j++){
758     delete hZNChg[j];
759     delete hZPChg[j];
760     delete hZNAhg[j];
761     delete hZPAhg[j];
762     delete hZNClg[j];
763     delete hZPClg[j];
764     delete hZNAlg[j];
765     delete hZPAlg[j];
766     /*if(j<2){
767       delete hZEMhg[j];
768       delete hZEMlg[j];
769     }*/
770   }
771   delete hPMRefChg;
772   delete hPMRefAhg;
773   delete hPMRefClg;
774   delete hPMRefAlg;
775
776   /* write report */
777   fprintf(fp,"Run #%s, received %d physics events out of %d\n",getenv("DATE_RUN_NUMBER"),nevents_physics,nevents_total);
778
779   /* close result file */
780   fclose(fp);
781   
782   /* report progress */
783   daqDA_progressReport(90);
784   
785   /* store the result file on FES */
786   // [1] File with mapping
787   status = daqDA_FES_storeFile(MAPDATA_FILE, "MAPPING");
788   if(status){
789     printf("Failed to export file : %d\n",status);
790     return -1;
791   }
792   //
793   // [2] File with laser data
794   status = daqDA_FES_storeFile(LASDATA_FILE, "LASERDATA");
795   if(status){
796     printf("Failed to export file : %d\n",status);
797     return -1;
798   }
799   // [3] File with laser histos
800   status = daqDA_FES_storeFile(LASHISTO_FILE, "LASERHISTOS");
801   if(status){
802     printf("Failed to export pedestal histos file to DAQ FES\n");
803     return -1;
804   }
805
806   /* report progress */
807   daqDA_progressReport(100);
808
809   return status;
810 }