Last modification from LM in agreement with Paolo. Pedestal file structure changed...
[u/mrichter/AliRoot.git] / HMPID / AliHMPIDCalib.cxx
1 //  **************************************************************************
2 //  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 //  *                                                                        *
4 //  * Author: The ALICE Off-line Project.                                    *
5 //  * Contributors are mentioned in the code where appropriate.              *
6 //  *                                                                        *
7 //  * Permission to use, copy, modify and distribute this software and its   *
8 //  * documentation strictly for non-commercial purposes is hereby granted   *
9 //  * without fee, provided that the above copyright notice appears in all   *
10 //  * copies and that both the copyright notice and this permission notice   *
11 //  * appear in the supporting documentation. The authors make no claims     *
12 //  * about the suitability of this software for any purpose. It is          *
13 //  * provided "as is" without express or implied warranty.                  *
14 //  **************************************************************************
15
16 #include "AliHMPIDCalib.h" //class header
17 #include "AliHMPIDParam.h" //class header
18 #include "AliHMPIDRawStream.h" //class header
19 #include "AliHMPIDDigit.h" //class header
20 #include <fstream>
21 #include <TTree.h>
22 #include <TSystem.h>
23 #include <TTimeStamp.h>
24
25
26
27
28
29 ClassImp(AliHMPIDCalib) 
30
31
32 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
33 AliHMPIDCalib::AliHMPIDCalib():
34 faddl(0x0),
35 fsq(0x0),
36 fsq2(0x0),
37 fnpc(0x0),
38 fpedQ0(0x0),
39 fErr(0x0),
40 fPadAdc(0x0),
41 fIsPad(0x0),
42 fFile(0x0),
43 fLdcId(0),
44 fTimeStamp(0),
45 fRunNum(0),
46 fSigCut(0),
47 fWritePads(0),
48 fnDDLInStream(0x0),
49 fnDDLOutStream(0x0),
50 fLargeHisto(kFALSE),
51 fSelectDDL(0),  
52 fDaOut(0),
53 fFeeIn(0)
54 {
55   //
56   //constructor
57   //
58   faddl = new Bool_t[AliHMPIDRawStream::kNDDL];
59   Int_t nPads =  (AliHMPIDParam::kMaxCh+1)*(AliHMPIDParam::kMaxPcx+1)*(AliHMPIDParam::kMaxPcy+1);
60  
61   fpedQ0 = new Int_t***[AliHMPIDRawStream::kNDDL+1];
62   fsq2   = new Float_t ***[AliHMPIDRawStream::kNDDL+1];
63   fsq    = new Float_t ***[AliHMPIDRawStream::kNDDL+1];
64   fnpc   = new Int_t ***[AliHMPIDRawStream::kNDDL+1];
65     fErr = new Int_t*[AliHMPIDRawStream::kNDDL+1];
66    
67   fnDDLInStream  = new Int_t[AliHMPIDRawStream::kNDDL+1];
68   fnDDLOutStream = new Int_t[AliHMPIDRawStream::kNDDL+1];
69
70   
71   for(Int_t iDDL=0;iDDL<AliHMPIDRawStream::kNDDL+1;iDDL++) {
72     
73       fErr[iDDL] = new Int_t[AliHMPIDRawStream::kSumErr+1];
74     fpedQ0[iDDL] = new Int_t**[AliHMPIDRawStream::kNRows+1];
75        fsq[iDDL] = new Float_t**[AliHMPIDRawStream::kNRows+1];
76       fsq2[iDDL] = new Float_t**[AliHMPIDRawStream::kNRows+1];
77       fnpc[iDDL] = new Int_t**[AliHMPIDRawStream::kNRows+1];
78       
79       for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++)  {
80       
81        fpedQ0[iDDL][iRow] = new Int_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
82           fsq[iDDL][iRow] = new Float_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
83          fsq2[iDDL][iRow] = new Float_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
84          fnpc[iDDL][iRow] = new Int_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
85       
86         for(Int_t iDil=1;iDil<AliHMPIDRawStream::kNDILOGICAdd+1;iDil++){
87       
88          fpedQ0[iDDL][iRow][iDil] = new Int_t[AliHMPIDRawStream::kNPadAdd+1];
89            fsq2[iDDL][iRow][iDil] = new Float_t[AliHMPIDRawStream::kNPadAdd+1];
90             fsq[iDDL][iRow][iDil] = new Float_t[AliHMPIDRawStream::kNPadAdd+1];
91            fnpc[iDDL][iRow][iDil] = new Int_t[AliHMPIDRawStream::kNPadAdd+1];
92           }//iDil
93       }//iRow
94    }//iDDL
95     
96    for(Int_t iDDL=0;iDDL<AliHMPIDRawStream::kNDDL+1;iDDL++) {
97         
98      fnDDLInStream[iDDL]=-1;
99      fnDDLOutStream[iDDL]=-1;
100       
101      for(Int_t iErr=0;iErr<AliHMPIDRawStream::kSumErr+1;iErr++)  {fErr[iDDL][iErr]=0;}
102          
103      for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++) {
104         for(Int_t iDil=1;iDil<AliHMPIDRawStream::kNDILOGICAdd+1;iDil++) {
105           for(Int_t iPad=1;iPad<AliHMPIDRawStream::kNPadAdd+1;iPad++) {
106             fpedQ0[iDDL][iRow][iDil][iPad]=0;
107                fsq[iDDL][iRow][iDil][iPad]=0;
108               fsq2[iDDL][iRow][iDil][iPad]=0;
109               fnpc[iDDL][iRow][iDil][iPad]=0;
110         }//iPad
111       }//iDil
112      }//iRow
113    }//iDDL
114     
115   fPadAdc=new TH1I*[nPads];  
116   fIsPad=new Bool_t[nPads];  
117   for(Int_t np=0;np<nPads;np++) {fPadAdc[np]=0x0;   fIsPad[np]=kFALSE;}
118   fWritePads=kFALSE;
119
120
121   Init();
122 }
123 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
124 AliHMPIDCalib::~AliHMPIDCalib()
125 {
126   //
127   //destructor
128   //
129   if (faddl)     { delete [] faddl;   faddl = 0x0;  } 
130   if (fPadAdc)   { delete [] fPadAdc; fPadAdc=0x0;  }  
131   if (fIsPad)    { delete [] fIsPad;  fIsPad=0x0;   }  
132   if (fFile)     { delete    fFile;   fFile=0x0;    }  
133  
134   for(Int_t iErr=0;iErr<AliHMPIDRawStream::kSumErr+1;iErr++) { delete [] fErr[iErr];}  delete [] fErr;
135   
136   for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++) 
137    for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++)         
138      for(Int_t iDil=1;iDil<AliHMPIDRawStream::kNDILOGICAdd+1;iDil++)
139       {
140          delete [] fpedQ0[iDDL][iRow][iDil]; //del iPad
141          delete []    fsq[iDDL][iRow][iDil]; //del iPad
142          delete []   fsq2[iDDL][iRow][iDil]; //del iPad
143          delete []   fnpc[iDDL][iRow][iDil]; //del iPad
144        }
145    for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++) 
146      for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++)         
147       {
148         delete [] fpedQ0[iDDL][iRow];  //del iRow
149           delete []  fsq[iDDL][iRow];  //del iRow
150           delete [] fsq2[iDDL][iRow];  //del iRow
151           delete [] fnpc[iDDL][iRow];  //del iRow
152         }
153        
154    for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++) 
155    {   
156        delete [] fpedQ0[iDDL];        //del iRow
157          delete [] fsq2[iDDL];        //del iRow
158          delete []  fsq[iDDL];        //del iRow
159          delete [] fnpc[iDDL];        //del iRow
160      }
161        
162    delete [] fpedQ0;
163    delete [] fsq2;
164    delete [] fsq;
165    delete [] fnpc;
166     
167   fpedQ0=0;    
168     fsq2=0;
169      fsq=0;
170     fnpc=0;
171     
172   fLdcId=0;
173   fTimeStamp=0;
174   fRunNum=0;
175   fSigCut=0;
176   fWritePads=0;
177   fLargeHisto=kFALSE;
178   fSelectDDL=0;
179 }//dtor
180 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
181 void AliHMPIDCalib::Init()
182 {
183   //
184   //Init the q calc.
185   //Arguments: none
186   //Return: none
187   //
188     
189   fSigCut=3;  //the standard cut
190   fFeeIn="";
191   fDaOut="";
192   
193       
194   for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++) 
195       {
196          for(Int_t ierr=0; ierr <AliHMPIDRawStream::kSumErr ; ierr++) {
197             fErr[iDDL][ierr]=0;
198             }
199         
200         faddl[iDDL]=kFALSE;
201       }//DDL
202 }//Init()
203 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
204 void AliHMPIDCalib::SetRunParams(ULong_t runNum,Int_t timeStamp, Int_t ldcId)
205 {
206   //  
207   //Set run parameters for the Pedestal and Error Files
208   //Arguments: run number, time stamp and LDC Id
209   //Returns: none
210   //
211   fRunNum=(Int_t)runNum;
212   fTimeStamp=timeStamp;
213   fLdcId=ldcId;
214 }//SetRunParams()
215 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
216 void AliHMPIDCalib::SetSigCutFromFile(Char_t* name)
217 {
218   //
219   //Set Sigma Cut from the file on the LDC, if the input file is not present default value is set!
220   //Arguments: the name of the SigmaCut file on the LDC
221   //Returns: none
222   //
223   Int_t nSigCut=0;
224   ifstream infile(name);
225   if(!infile.is_open()) {fSigCut=3; return;}
226   while(!infile.eof())
227     {
228     infile>>nSigCut;
229   }
230   infile.close();
231   fSigCut=nSigCut; 
232 }//SetSigCutFromFile()    
233 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
234 void AliHMPIDCalib::SetSigCutFromShell(Char_t *env)
235 {
236   //
237   //Set Sigma Cut from the Shell on the LDC, if the input file is not present default value is set!
238   //Arguments: none
239   //Returns: none
240   //
241   Int_t nSigCut=0;
242   TString ssc(gSystem->Getenv(env));
243   //make it nicer later...
244        if(ssc=="1") {  nSigCut=1;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
245   else if(ssc=="2") {  nSigCut=2;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
246   else if(ssc=="3") {  nSigCut=3;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
247   else if(ssc=="4") {  nSigCut=4;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
248   else if(ssc=="5") {  nSigCut=5;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
249   else if(ssc=="6") {  nSigCut=6;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
250   else if(ssc=="7") {  nSigCut=7;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
251   else if(ssc=="8") {  nSigCut=8;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
252   else if(ssc=="9") {  nSigCut=9;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
253   else if(ssc=="10") {  nSigCut=10;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
254   else if(ssc=="11") {  nSigCut=11;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
255   else if(ssc=="12") {  nSigCut=12;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
256   else if(ssc=="13") {  nSigCut=13;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
257   else if(ssc=="14") {  nSigCut=14;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
258   else if(ssc=="15") {  nSigCut=15;  Printf("DAQ Sigma Cut from shell is: %d",nSigCut);}
259   else  {  nSigCut=3;  Printf("DAQ Sigma Cut from shell is too large set it back to default: %d",nSigCut);}
260   
261   fSigCut=nSigCut; 
262 }//SetSigCutFromFile()    
263 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     void SetDaOutFromShell(Char_t* name);                             //Set out dir. of DA from Bash Shell
264 void AliHMPIDCalib::SetFeeInFromShell(Char_t* env)
265 {
266    //
267   //Set the path where the Fe2C is looking for the threshold files
268   //Arguments: none
269   //Returns: none
270   //
271   TString sFeeIn(gSystem->Getenv(env));
272   if(sFeeIn.Data()=="") sFeeIn="/local/home/hmpid/";
273   if(sFeeIn.EndsWith("/")) fFeeIn=sFeeIn;
274   else fFeeIn=Form("%s/",sFeeIn.Data());
275   if(gSystem->OpenDirectory(fFeeIn.Data())==0) 
276   {
277     Printf("========== HMPID-DA WARNING: directory %s does not exist! Switching to /tmp! ==========",fFeeIn.Data());
278     fFeeIn="/tmp/";
279   }
280   Printf("HMPID_FEE_IN=%s",fFeeIn.Data()); 
281 }
282 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     void SetDaOutFromShell(Char_t* name);                             //Set out dir. of DA from Bash Shell
283 void AliHMPIDCalib::SetDaOutFromShell(Char_t* env)
284 {
285    //
286   //Set the standard path where the DA write the output
287   //Arguments: none
288   //Returns: none
289   //
290   TString sDaOut(gSystem->Getenv(env));
291   if(sDaOut=="") sDaOut="/local/home/hmpid/";
292   if(sDaOut.EndsWith("/")) fDaOut=sDaOut;
293   else fDaOut=Form("%s/",sDaOut.Data());
294   
295   if(gSystem->OpenDirectory(fDaOut.Data())==0) 
296   {
297     Printf("========== HMPID-DA WARNING: directory %s does not exist! Switching to /tmp! ==========",fDaOut.Data());
298     fDaOut="/tmp/";
299   } 
300   Printf("HMPID_DA_OUT=%s",fDaOut.Data()); 
301 }
302 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
303 void AliHMPIDCalib::InitHisto(Int_t q,Int_t histocnt,Char_t* name)
304 {
305   //
306   //Init the pad histos. For one DDL we have 11520 pads. ONLY if ENABLED!
307   //Arguments: q-charge, the absolute number of the histogram (AliHMPIDParam::kMaxCh+1)*(AliHMPIDParam::kMaxPcx+1)*(AliHMPIDParam::kMaxPcy+1) and the name of the histogram (unique) 
308   //Returns: none
309   //
310  if(fWritePads==kFALSE) return;
311  fFile->cd();
312  Double_t lowbin,highbin=0;
313  lowbin=q-40.5; highbin=q+40.5;  
314  
315  if(fIsPad[histocnt]==kTRUE) return;
316  
317  if(fLargeHisto==kFALSE) fPadAdc[histocnt]=new TH1I(name,name,81,lowbin,highbin);
318  if(fLargeHisto==kTRUE) fPadAdc[histocnt]=new TH1I(name,name,4093,-0.5,4092.5);
319  fPadAdc[histocnt]->Sumw2();
320  fIsPad[histocnt]=kTRUE;
321  
322 }//InitHisto()
323 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
324 void AliHMPIDCalib::FillHisto(Int_t histocnt,Int_t q)
325 {
326   //
327   //Fill the ADC histograms for each pad
328   //Arguments:  q-charge, the absolute number of the histogram (AliHMPIDParam::kMaxCh+1)*(AliHMPIDParam::kMaxPcx+1)*(AliHMPIDParam::kMaxPcy+1)
329   //Returns: none
330   //
331   if(fIsPad[histocnt]==kFALSE) return;
332   fFile->cd();
333   fPadAdc[histocnt]->Fill(q);
334  
335 }//InitHisto()
336 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
337 void AliHMPIDCalib::InitFile(Int_t inVal)
338 {
339   //
340   //Initialize the ADC histo output file (one per LDC)
341   //Arguments: LDC Id
342   //Returns: none
343   //
344   if(fWritePads==kFALSE ) return;
345   if(fLargeHisto==kFALSE) fFile=new TFile(Form("HmpidPadsOnLdc%2d.root",inVal),"RECREATE");
346   if(fLargeHisto==kTRUE)  fFile=new TFile(Form("Run%d_DDL%d.root",inVal,fSelectDDL),"RECREATE"); 
347   
348 }//InitFile()
349 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
350 void AliHMPIDCalib::CloseFile()
351 {
352   //
353   //Close the ADC histo output file (one per LDC)
354   //Arguments: LDC Id
355   //Returns: none
356   //
357   fFile->cd();
358   Int_t nPads = (AliHMPIDParam::kMaxCh+1)*(AliHMPIDParam::kMaxPcx+1)*(AliHMPIDParam::kMaxPcy+1);
359   for(Int_t np=0;np<nPads;np++) {if(fIsPad[np]==kTRUE) fPadAdc[np]->Write();} 
360   fFile->Close();
361 }//CloseFile()
362 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
363 void AliHMPIDCalib::FillPedestal(Int_t abspad,Int_t q)
364 {
365   //
366   //Called from the HMPIDda and fills the pedestal values
367   //Arguments: absolute pad number as from AliHMPIDParam and q-charge
368   //Returns: none
369   //
370   if(q<0) AliFatal("Negative charge is read!!!!!!");
371   
372   UInt_t w32;
373   Int_t nDDL=0, row=0, dil=0, adr=0;
374   //The decoding (abs. pad -> ddl,dil,...) is the same as in AliHMPIDDigit::Raw
375   
376   AliHMPIDDigit dig(abspad,q);
377   dig.Raw(w32,nDDL,row,dil,adr);
378   
379   //........... decoding done      
380
381      if(q>0) { 
382         fsq[nDDL][row][dil][adr]+=q;
383       fsq2[nDDL][row][dil][adr]+=q*q;
384       fnpc[nDDL][row][dil][adr]++;                                                     //Count how many times the pad is good (can be different from the good DDL  count)
385                        faddl[nDDL]=kTRUE; 
386                      }
387       else
388       {
389         fpedQ0[nDDL][row][dil][adr]++;                                                 //Count how many times a pad charge is zero
390       }
391       
392      Int_t histocnt=0;   histocnt=(nDDL)*11520+(row-1)*480+(dil-1)*48+adr;             //Histo counter for a single DDL  
393      
394      if(fWritePads==kTRUE)                                                             //works but make it nicer later....
395      { 
396        if( fLargeHisto==kTRUE && nDDL==fSelectDDL) {              
397          InitHisto(q,histocnt,Form("hDDL_%d_Row_%d_Dil_%d_Pad_%d",nDDL,row,dil,adr));  //for large histos use hardware naming
398          FillHisto(histocnt,q);
399         }
400         if(fLargeHisto==kFALSE)
401         {
402          InitHisto(q,histocnt,Form("hPad_Ch_%d_Pc_%d_Px_%d_Py_%d",AliHMPIDParam::A2C(abspad),AliHMPIDParam::A2P(abspad),AliHMPIDParam::A2X(abspad),AliHMPIDParam::A2Y(abspad))); 
403          FillHisto(histocnt,q);  
404         }
405       }//fWritePads
406             
407 }//FillPedestal()
408 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
409 void AliHMPIDCalib::FillErrors(Int_t nDDL,Int_t eType, Int_t nErr)
410 {
411   //
412   //Fill decoding errors from AliHMPIDRawStream
413   //Arguments: nDDL-DDL number, eType- error type as in AliHMPIDRawStream.h and the # of occurence for eType
414   //Retutns: none
415   //
416     if(nErr<=0) return;
417     if(eType < 0 || eType> AliHMPIDRawStream::kSumErr ) return;
418     fErr[nDDL][eType]=fErr[nDDL][eType]+nErr;
419     
420   
421 }//FillErrors()
422 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
423 void AliHMPIDCalib::FillDDLCnt(Int_t iddl,Int_t inDDL, Int_t outDDL)
424 {
425   //
426   //Fill decoding DDL check from RawStream
427   //Arguments: iddl - DDL under setting, inDDL- How many times the DDL is present in the raw stream, outDDL - How many time sthe DDL is succesfylly decoded
428   //Retutns: none
429   //
430  
431   if(inDDL==-1) return;
432   if(fnDDLInStream[iddl]==-1) {fnDDLInStream[iddl]=0; fnDDLOutStream[iddl]=0;}
433   fnDDLInStream[iddl]+=inDDL;
434   fnDDLOutStream[iddl]+=outDDL;
435  
436   
437 }//FillDDLCnt()
438 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
439 Bool_t AliHMPIDCalib::WriteErrors(Int_t nDDL, Char_t* name, Int_t nEv)
440 {
441   //
442   //Write decoding errors to a txt file
443   //Arguments: nDDL-DDL number, name of the error file and number of the read events
444   //Retutns: kTRUE/kFALSE
445   //  
446   if(faddl[nDDL]==kFALSE) return kFALSE;                                                                 //if ddl is missing no error file is created
447   ofstream outerr;  outerr.open(name);                                                                   //open error file
448   outerr << Form("%8s %2d\n","RunNumber",(Int_t)fRunNum);                                                //read run number
449   outerr << Form("%8s %2d\n","LdcId" ,          fLdcId);                                                 //read LDC Id
450   outerr << Form("%8s %2d\n","TimeStamp",       fTimeStamp);                                             //read time stamp
451   outerr << Form("%8s %2d\n","TotNumEvt",       nEv);                                                    //read number of total events processed
452   outerr << Form("%8s %2d\n","TotDDLEvt",       fnDDLInStream[nDDL]);                                    //read number of bad events for DDL # nDDL processed
453   outerr << Form("%8s %2d\n","NumBadEvt",       fnDDLInStream[nDDL]-fnDDLOutStream[nDDL]);               //read number of bad events for DDL # nDDL processed
454   outerr << Form("%8s %2.2f\n","NBadE(%)",      (fnDDLInStream[nDDL]-fnDDLOutStream[nDDL])*100.0/nEv);   //read number of bad events (in %) for DDL # nDDL processed
455   
456   for(Int_t  ierr=0; ierr <AliHMPIDRawStream::kSumErr; ierr++) outerr << Form("%2d\t",fErr[nDDL][ierr]); //write errors
457                                                                outerr << Form("\n");                     //last break
458   /* write out pads with 0 charge read */
459   for(Int_t row = 1; row <= AliHMPIDRawStream::kNRows; row++){
460     for(Int_t dil = 1; dil <= AliHMPIDRawStream::kNDILOGICAdd; dil++){
461       for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){
462         if(fpedQ0[nDDL][row][dil][pad]>0) outerr<< Form("%2d %2d %2d %3d\n",row,dil,pad,fpedQ0[nDDL][row][dil][pad]);
463       }
464     }
465   } 
466                                                                                                                                                                                        
467                                                                
468   outerr.close();                                                                                        //write error file
469   
470   return kTRUE;
471     
472 }//FillErrors()
473 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
474 Bool_t AliHMPIDCalib::CalcPedestal(Int_t nDDL, Char_t* name, Int_t nEv)    
475 {
476   //
477   //Calculate pedestal for each pad  
478   //Arguments: nDDL-DDL number, name of the pedestal file and number of the read events
479   //Retutns: kTRUE/kFALSE
480   //
481   
482   if(faddl[nDDL]==kFALSE) return kFALSE;                   //if ddl is missing no ped file is created (and also for LDC selection). Check with Paolo what he checks for?!  
483   Int_t ddlOffset=1536;
484   Int_t feeOffset=196657;
485   ofstream feeInput[24]; 
486   
487   for(Int_t ir=0;ir<AliHMPIDRawStream::kNRows;ir++) feeInput[ir].open(Form("%sthr%d_%d.dat",fFeeIn.Data(),ddlOffset+nDDL,ir+1));  //for Fe2C every row has a file only with inhard        
488
489   Double_t mean=0,sigma=0;
490   Double_t qs2m=0,qsm2=0;
491   ofstream out;                                           //to write the pedestal text files
492   Int_t inhard;
493   Int_t nEvPerPad=0;
494   out.open(name);
495   out << Form("%8s %2d\n","RunNumber",(Int_t)fRunNum);                                                //read run number
496   out << Form("%8s %2d\n","LdcId" ,         fLdcId);                                                  //read LDC Id
497   out << Form("%8s %2d\n","TimeStamp",      fTimeStamp);                                              //read time stamp
498   out << Form("%8s %2d\n","TotNumEvt",      nEv);                                                     //read number of total events processed
499   out << Form("%8s %2d\n","TotDDLEvt",      fnDDLInStream[nDDL]);                                     //read number of bad events for DDL # nDDL processed
500   out << Form("%8s %2d\n","NumBadEvt",      fnDDLInStream[nDDL]-fnDDLOutStream[nDDL]);                //read number of bad events for DDL # nDDL processed
501   out << Form("%8s %2f\n","NBadE(%)",       (fnDDLInStream[nDDL]-fnDDLOutStream[nDDL])*100.0/nEv);    //read number of bad events (in %) for DDL # nDDL processed
502   out << Form("%8s %2.2d\n","#SigCut",      fSigCut);                                                 //# of sigma cuts
503       
504   for(Int_t row = 1; row <= AliHMPIDRawStream::kNRows; row++){
505     //write thr file for Fe2C
506    
507     for(Int_t dil = 1; dil <= AliHMPIDRawStream::kNDILOGICAdd; dil++){
508       for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){
509         
510         mean  = 50;sigma = 100;
511         
512         nEvPerPad=fnpc[nDDL][row][dil][pad];
513         
514         if(nEvPerPad < 1 ) {                    //if the pad is bad then we assign 100  for the sigma and 50 for the mean
515           mean  = 4000;
516           sigma = 1000;
517         }
518         else{        
519          mean = fsq[nDDL][row][dil][pad]*1.0/nEvPerPad;
520          qs2m = fsq2[nDDL][row][dil][pad]*1.0/nEvPerPad;
521          qsm2 = TMath::Power(fsq[nDDL][row][dil][pad]*1.0/nEvPerPad,2); 
522         sigma = TMath::Sqrt(TMath::Abs(qs2m-qsm2));
523         }
524             
525         inhard=((Int_t(mean+fSigCut*sigma))<<9)+Int_t(mean); //right calculation, xchecked with Paolo 8/4/2008
526         out << Form("%2i %2i %2i %5.3f %5.3f %4.4x \n",row,dil,pad,mean,sigma,inhard);
527
528         feeInput[row-1] << Form("0x%4.4x\n",inhard);                 
529        //if(sigma > 3.0) Printf("WARNING SIGMA DDL: %2d row: %2d dil: %2d pad: %2d mean: %3.2f sigma: %2.2f nEvPerPad: %02d fnDDLOutStream: %02d fpedQ0: %02d",nDDL,row,dil,pad,mean,sigma,nEvPerPad,fnDDLOutStream[nDDL],fpedQ0[nDDL][row][dil][pad]);         
530         }//adr
531         
532         //we have to write up to 64 not 48 in the DILOGIC since they are daisy chained!
533         //offset and format is defined for the Fe2C code
534         for(Int_t idd=0;idd<16;idd++) feeInput[row-1] << Form("0x%4.4x\n",idd+feeOffset);                 
535       }//dil
536       
537       
538     }//row
539     out.close();                                          //write pedestal file
540     for(Int_t ir=0;ir<AliHMPIDRawStream::kNRows;ir++) feeInput[ir].close();
541  
542   return kTRUE;
543 }//CaclPedestal()
544 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
545 Bool_t AliHMPIDCalib::CalcPedestalPaolo(Int_t nDDL, Char_t* /*name*/, Int_t nEv)    
546 {
547   //
548   //Calculate pedestal for each pad  
549   //Arguments: nDDL-DDL number, name of the pedestal file and number of the read events
550   //Retutns: kTRUE/kFALSE
551   //
552   //----------------- write files in the format of Paolo -----------------------
553   if(faddl[nDDL]==kFALSE) return kFALSE;                   //if ddl is missing no ped file is created (and also for LDC selection). Check with Paolo what he checks for?!  
554   Int_t ddlOffset=1536;
555   Int_t cnt=0;
556   Double_t mean1=0,sigma1=0;
557   Double_t qs2m1=0,qsm21=0;
558   Double_t mean2=0,sigma2=0;
559   Double_t qs2m2=0,qsm22=0;
560   Int_t nEvPerPad1=0;
561   Int_t nEvPerPad2=0;
562     
563   ofstream pped[3]; 
564   for(Int_t iseg=1;iseg<4;iseg++) pped[iseg-1].open(Form("%sHmpidPed%d_%d.dat",fDaOut.Data(),nDDL+ddlOffset,iseg));
565     
566   for(Int_t row = 1; row <= AliHMPIDRawStream::kNRows/2; row++){
567      
568       //write header
569       pped[(row-1)/4]<<Form("ID_Nevt_NChan_Row_Row_P0_P1_S0_S1 \n");
570       pped[(row-1)/4]<<Form("%d  %d   %d    %d  %d %3.3lf %3.3lf %3.3lf %3.3lf \n",2*row-1,nEv,480,2*row-1,2*row,999.0,999.0,999.0,999.0);
571        
572       cnt=0; 
573       for(Int_t dil = 1; dil <= AliHMPIDRawStream::kNDILOGICAdd; dil++){
574       for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){
575         
576          nEvPerPad1=fnpc[nDDL][2*row-1][dil][pad];
577          nEvPerPad2=fnpc[nDDL][2*row][dil][pad];
578         
579         if(nEvPerPad1 < 1 ) { mean1  = 4000; sigma1 = 1000; }
580         if(nEvPerPad2 < 1 ) { mean2  = 4000; sigma2 = 1000; }
581                 
582          mean1 = fsq[nDDL][2*row-1][dil][pad]*1.0/nEvPerPad1;
583          qs2m1 = fsq2[nDDL][2*row-1][dil][pad]*1.0/nEvPerPad1;
584          qsm21 = TMath::Power(fsq[nDDL][2*row-1][dil][pad]*1.0/nEvPerPad1,2); 
585         sigma1 = TMath::Sqrt(TMath::Abs(qs2m1-qsm21));
586        
587          mean2 = fsq[nDDL][2*row][dil][pad]*1.0/nEvPerPad2;
588          qs2m2 = fsq2[nDDL][2*row][dil][pad]*1.0/nEvPerPad2;
589          qsm22 = TMath::Power(fsq[nDDL][2*row][dil][pad]*1.0/nEvPerPad2,2); 
590         sigma2 = TMath::Sqrt(TMath::Abs(qs2m2-qsm22));
591         
592         pped[(row-1)/4]<<Form("%d %3.3lf %3.3lf %3.3lf %3.3lf \n",cnt,mean1,sigma1,mean2,sigma2);cnt++;
593       }//pad
594       }//dil 
595      }//row    
596     for(Int_t ir=0;ir<3;ir++) {pped[ir].close();    }  
597    return kTRUE;
598 }//CalcPedestalPaolo()
599 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
600
601