[u/mrichter/AliRoot.git] / HMPID / AliHMPIDCalib.cxx

//  **************************************************************************
//  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
//  *                                                                        *
//  * Author: The ALICE Off-line Project.                                    *
//  * Contributors are mentioned in the code where appropriate.              *
//  *                                                                        *
//  * Permission to use, copy, modify and distribute this software and its   *
//  * documentation strictly for non-commercial purposes is hereby granted   *
//  * without fee, provided that the above copyright notice appears in all   *
//  * copies and that both the copyright notice and this permission notice   *
//  * appear in the supporting documentation. The authors make no claims     *
//  * about the suitability of this software for any purpose. It is          *
//  * provided "as is" without express or implied warranty.                  *
//  **************************************************************************

#include "AliHMPIDCalib.h" //class header
#include "AliHMPIDParam.h" //class header
#include "AliHMPIDRawStream.h" //class header
#include <fstream>
#include <TTree.h>


ClassImp(AliHMPIDCalib) 


//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AliHMPIDCalib::AliHMPIDCalib():
faddl(0x0),
fsq(0x0),
fsq2(0x0),
fnpc(0x0),
fpedQ0(0x0),
fErr(0x0),
fPadAdc(0x0),
fIsPad(0x0),
fFile(0x0),
fLdcId(0),
fTimeStamp(0),
fRunNum(0),
fSigCut(0),
fWritePads(0),
fnDDLInStream(0x0),
fnDDLOutStream(0x0),
fLargeHisto(kFALSE),
fSelectDDL(0)  
{
  //
  //constructor
  //
  faddl = new Bool_t[AliHMPIDRawStream::kNDDL];
  Int_t nPads =  (AliHMPIDParam::kMaxCh+1)*(AliHMPIDParam::kMaxPcx+1)*(AliHMPIDParam::kMaxPcy+1);
 
  fpedQ0 = new Int_t***[AliHMPIDRawStream::kNDDL+1];
  fsq2   = new Float_t ***[AliHMPIDRawStream::kNDDL+1];
  fsq    = new Float_t ***[AliHMPIDRawStream::kNDDL+1];
  fnpc   = new Int_t ***[AliHMPIDRawStream::kNDDL+1];
    fErr = new Int_t*[AliHMPIDRawStream::kNDDL+1];
   
  fnDDLInStream  = new Int_t[AliHMPIDRawStream::kNDDL+1];
  fnDDLOutStream = new Int_t[AliHMPIDRawStream::kNDDL+1];

  
  for(Int_t iDDL=0;iDDL<AliHMPIDRawStream::kNDDL+1;iDDL++) {
    
      fErr[iDDL] = new Int_t[AliHMPIDRawStream::kSumErr+1];
    fpedQ0[iDDL] = new Int_t**[AliHMPIDRawStream::kNRows+1];
       fsq[iDDL] = new Float_t**[AliHMPIDRawStream::kNRows+1];
      fsq2[iDDL] = new Float_t**[AliHMPIDRawStream::kNRows+1];
      fnpc[iDDL] = new Int_t**[AliHMPIDRawStream::kNRows+1];
      
      for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++)  {
      
       fpedQ0[iDDL][iRow] = new Int_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
          fsq[iDDL][iRow] = new Float_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
         fsq2[iDDL][iRow] = new Float_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
         fnpc[iDDL][iRow] = new Int_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
      
        for(Int_t iDil=1;iDil<AliHMPIDRawStream::kNDILOGICAdd+1;iDil++){
      
         fpedQ0[iDDL][iRow][iDil] = new Int_t[AliHMPIDRawStream::kNPadAdd+1];
           fsq2[iDDL][iRow][iDil] = new Float_t[AliHMPIDRawStream::kNPadAdd+1];
            fsq[iDDL][iRow][iDil] = new Float_t[AliHMPIDRawStream::kNPadAdd+1];
           fnpc[iDDL][iRow][iDil] = new Int_t[AliHMPIDRawStream::kNPadAdd+1];
          }//iDil
      }//iRow
   }//iDDL
    
   for(Int_t iDDL=0;iDDL<AliHMPIDRawStream::kNDDL+1;iDDL++) {
        
     fnDDLInStream[iDDL]=-1;
     fnDDLOutStream[iDDL]=-1;
      
     for(Int_t iErr=0;iErr<AliHMPIDRawStream::kSumErr+1;iErr++)  {fErr[iDDL][iErr]=0;}
         
     for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++) {
        for(Int_t iDil=1;iDil<AliHMPIDRawStream::kNDILOGICAdd+1;iDil++) {
          for(Int_t iPad=1;iPad<AliHMPIDRawStream::kNPadAdd+1;iPad++) {
            fpedQ0[iDDL][iRow][iDil][iPad]=0;
               fsq[iDDL][iRow][iDil][iPad]=0;
              fsq2[iDDL][iRow][iDil][iPad]=0;
              fnpc[iDDL][iRow][iDil][iPad]=0;
        }//iPad
      }//iDil
     }//iRow
   }//iDDL
    
  fPadAdc=new TH1I*[nPads];  
  fIsPad=new Bool_t[nPads];  
  for(Int_t np=0;np<nPads;np++) {fPadAdc[np]=0x0;   fIsPad[np]=kFALSE;}
  fWritePads=kFALSE;


  Init();
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AliHMPIDCalib::~AliHMPIDCalib()
{
  //
  //destructor
  //
  if (faddl)     { delete [] faddl;   faddl = 0x0;  } 
  if (fPadAdc)   { delete [] fPadAdc; fPadAdc=0x0;  }  
  if (fIsPad)    { delete [] fIsPad;  fIsPad=0x0;   }  
  if (fFile)     { delete    fFile;   fFile=0x0;    }  
 
  for(Int_t iErr=0;iErr<AliHMPIDRawStream::kSumErr+1;iErr++) { delete [] fErr[iErr];}  delete [] fErr;
  
  for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++) 
   for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++)         
     for(Int_t iDil=1;iDil<AliHMPIDRawStream::kNDILOGICAdd+1;iDil++)
      {
         delete [] fpedQ0[iDDL][iRow][iDil]; //del iPad
         delete []    fsq[iDDL][iRow][iDil]; //del iPad
         delete []   fsq2[iDDL][iRow][iDil]; //del iPad
         delete []   fnpc[iDDL][iRow][iDil]; //del iPad
       }
   for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++) 
     for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++)         
      {
        delete [] fpedQ0[iDDL][iRow];  //del iRow
          delete []  fsq[iDDL][iRow];  //del iRow
          delete [] fsq2[iDDL][iRow];  //del iRow
          delete [] fnpc[iDDL][iRow];  //del iRow
        }
       
   for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++) 
   {   
       delete [] fpedQ0[iDDL];        //del iRow
         delete [] fsq2[iDDL];        //del iRow
         delete []  fsq[iDDL];        //del iRow
         delete [] fnpc[iDDL];        //del iRow
     }
       
   delete [] fpedQ0;
   delete [] fsq2;
   delete [] fsq;
   delete [] fnpc;
    
  fpedQ0=0;    
    fsq2=0;
     fsq=0;
    fnpc=0;
    
  fLdcId=0;
  fTimeStamp=0;
  fRunNum=0;
  fSigCut=0;
  fWritePads=0;
  fLargeHisto=kFALSE;
  fSelectDDL=0;
}//dtor
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDCalib::Init()
{
  //
  //Init the q calc.
  //Arguments: none
  //Return: none
  //
    fSigCut=3;  
    for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++) 
      {
         for(Int_t ierr=0; ierr <AliHMPIDRawStream::kSumErr ; ierr++) {
            fErr[iDDL][ierr]=0;
            }
        
        faddl[iDDL]=kFALSE;
      }//DDL
}//Init()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDCalib::SetRunParams(ULong_t runNum,Int_t timeStamp, Int_t ldcId)
{
  //  
  //Set run parameters for the Pedestal and Error Files
  //Arguments: run number, time stamp and LDC Id
  //Returns: none
  //
  fRunNum=(Int_t)runNum;
  fTimeStamp=timeStamp;
  fLdcId=ldcId;
}//SetRunParams()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDCalib::SetSigCutFromFile(Char_t* name)
{
  //
  //Set Sigma Cut from the file on the LDC, if the input file is not present default value is set!
  //Arguments: the name of the SigmaCut file on the LDC
  //Returns: none
  //
  Int_t nSigCut=0;
  ifstream infile(name);
  if(!infile.is_open()) {fSigCut=3; return;}
  while(!infile.eof())
    {
    infile>>nSigCut;
  }
  infile.close();
  fSigCut=nSigCut; 
}//SetSigCutFromFile()    
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
void AliHMPIDCalib::InitHisto(Int_t q,Int_t histocnt,Char_t* name)
{
  //
  //Init the pad histos. For one DDL we have 11520 pads. ONLY if ENABLED!
  //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) 
  //Returns: none
  //
 if(fWritePads==kFALSE) return;
 fFile->cd();
 Double_t lowbin,highbin=0;
 lowbin=q-40.5; highbin=q+40.5;  
 
 if(fIsPad[histocnt]==kTRUE) return;
 
 if(fLargeHisto==kFALSE) fPadAdc[histocnt]=new TH1I(name,name,81,lowbin,highbin);
 if(fLargeHisto==kTRUE) fPadAdc[histocnt]=new TH1I(name,name,4093,-0.5,4092.5);
 fPadAdc[histocnt]->Sumw2();
 fIsPad[histocnt]=kTRUE;
 
}//InitHisto()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDCalib::FillHisto(Int_t histocnt,Int_t q)
{
  //
  //Fill the ADC histograms for each pad
  //Arguments:  q-charge, the absolute number of the histogram (AliHMPIDParam::kMaxCh+1)*(AliHMPIDParam::kMaxPcx+1)*(AliHMPIDParam::kMaxPcy+1)
  //Returns: none
  //
  if(fIsPad[histocnt]==kFALSE) return;
  fFile->cd();
  fPadAdc[histocnt]->Fill(q);
 
}//InitHisto()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDCalib::InitFile(Int_t inVal)
{
  //
  //Initialize the ADC histo output file (one per LDC)
  //Arguments: LDC Id
  //Returns: none
  //
  if(fWritePads==kFALSE ) return;
  if(fLargeHisto==kFALSE) fFile=new TFile(Form("HmpidPadsOnLdc%2d.root",inVal),"RECREATE");
  if(fLargeHisto==kTRUE)  fFile=new TFile(Form("Run%d_DDL%d.root",inVal,fSelectDDL),"RECREATE"); 
  
}//InitFile()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDCalib::CloseFile()
{
  //
  //Close the ADC histo output file (one per LDC)
  //Arguments: LDC Id
  //Returns: none
  //
  fFile->cd();
  Int_t nPads = (AliHMPIDParam::kMaxCh+1)*(AliHMPIDParam::kMaxPcx+1)*(AliHMPIDParam::kMaxPcy+1);
  for(Int_t np=0;np<nPads;np++) {if(fIsPad[np]==kTRUE) fPadAdc[np]->Write();} 
  fFile->Close();
}//CloseFile()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDCalib::FillPedestal(Int_t abspad,Int_t q)
{
  //
  //Called from the HMPIDda and fills the pedestal values
  //Arguments: absulote pad number as from AliHMPIDParam and q-charge
  //Returns: none
  //
  if(q<0) AliFatal("Negative charge is read!!!!!!");
  
  Int_t nDDL=0, row=0, dil=0, adr=0;
  //The decoding (abs. pad -> ddl,dil,...) is the same as in AliHMPIDDigit::Raw
  Int_t y2a[6]={5,3,1,0,2,4};

       nDDL=  2*AliHMPIDParam::A2C(abspad)+AliHMPIDParam::A2P(abspad)%2;              //DDL# 0..13
  Int_t tmp=   1+AliHMPIDParam::A2P(abspad)/2*8+AliHMPIDParam::A2Y(abspad)/6;         //temp variable
        row=   (AliHMPIDParam::A2P(abspad)%2)? tmp:25-tmp;                            //row r=1..24
        dil=  1+AliHMPIDParam::A2X(abspad)/8;                                         //DILOGIC 
        adr=y2a[AliHMPIDParam::A2Y(abspad)%6]+6*(AliHMPIDParam::A2X(abspad)%8);       //ADDRESS 0..47 
  //........... decoding done      

//     if(row<1 || row > 24 || nDDL < 0 || nDDL > 13 || dil < 1 || dil > 10 || adr < 0 || adr >47) AliFatal(Form("ddl %d row %d dil %d adr %d",nDDL,row,dil,adr));
            
       
     if(q>0) { 
        fsq[nDDL][row][dil][adr]+=q;
      fsq2[nDDL][row][dil][adr]+=q*q;
      fnpc[nDDL][row][dil][adr]++;                                                     //Count how many times the pad is good (can be different from the good DDL  count)
                       faddl[nDDL]=kTRUE; 
                     }
      else
      {
        fpedQ0[nDDL][row][dil][adr]++;                                                 //Count how many times a pad charge is zero
      }
      
     Int_t histocnt=0;   histocnt=(nDDL)*11520+(row-1)*480+(dil-1)*48+adr;             //Histo counter for a single DDL  
     
     if(fWritePads==kTRUE)                                                             //works but make it nicer later....
     { 
       if( fLargeHisto==kTRUE && nDDL==fSelectDDL) {              
         InitHisto(q,histocnt,Form("hDDL_%d_Row_%d_Dil_%d_Pad_%d",nDDL,row,dil,adr));  //for large histos use hardware naming
         FillHisto(histocnt,q);
        }
        if(fLargeHisto==kFALSE)
        {
         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))); 
         FillHisto(histocnt,q);  
        }
      }//fWritePads
            
}//FillPedestal()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDCalib::FillErrors(Int_t nDDL,Int_t eType, Int_t nErr)
{
  //
  //Fill decoding errors from AliHMPIDRawStream
  //Arguments: nDDL-DDL number, eType- error type as in AliHMPIDRawStream.h and the # of occurence for eType
  //Retutns: none
  //
    if(nErr<=0) return;
    if(eType < 0 || eType> AliHMPIDRawStream::kSumErr ) return;
    fErr[nDDL][eType]=fErr[nDDL][eType]+nErr;
    
  
}//FillErrors()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDCalib::FillDDLCnt(Int_t iddl,Int_t inDDL, Int_t outDDL)
{
  //
  //Fill decoding DDL check from RawStream
  //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
  //Retutns: none
  //
 
  if(inDDL==-1) return;
  if(fnDDLInStream[iddl]==-1) {fnDDLInStream[iddl]=0; fnDDLOutStream[iddl]=0;}
  fnDDLInStream[iddl]+=inDDL;
  fnDDLOutStream[iddl]+=outDDL;
 
  
}//FillDDLCnt()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Bool_t AliHMPIDCalib::WriteErrors(Int_t nDDL, Char_t* name, Int_t nEv)
{
  //
  //Write decoding errors to a txt file
  //Arguments: nDDL-DDL number, name of the error file and number of the read events
  //Retutns: kTRUE/kFALSE
  //
  
  if(faddl[nDDL]==kFALSE) return kFALSE;                                                                 //if ddl is missing no error file is created
  ofstream outerr;  outerr.open(name);                                                                   //open error file
  outerr << Form("%8s %2d\n","RunNumber",(Int_t)fRunNum);                                                //read run number
  outerr << Form("%8s %2d\n","LdcId" ,          fLdcId);                                                 //read LDC Id
  outerr << Form("%8s %2d\n","TimeStamp",       fTimeStamp);                                             //read time stamp
  outerr << Form("%8s %2d\n","TotNumEvt",       nEv);                                                    //read number of total events processed
  outerr << Form("%8s %2d\n","TotDDLEvt",       fnDDLInStream[nDDL]);                                    //read number of bad events for DDL # nDDL processed
  outerr << Form("%8s %2d\n","NumBadEvt",       fnDDLInStream[nDDL]-fnDDLOutStream[nDDL]);               //read number of bad events for DDL # nDDL processed
  outerr << Form("%8s %2.2f\n","NBadE(%)",      (fnDDLInStream[nDDL]-fnDDLOutStream[nDDL])*100.0/nEv);   //read number of bad events (in %) for DDL # nDDL processed
  
  for(Int_t  ierr=0; ierr <AliHMPIDRawStream::kSumErr; ierr++) outerr << Form("%2d\t",fErr[nDDL][ierr]); //write errors
                                                               outerr << Form("\n");                     //last break
  /* write out pads with 0 charge read */
  for(Int_t row = 1; row <= AliHMPIDRawStream::kNRows; row++){
    for(Int_t dil = 1; dil <= AliHMPIDRawStream::kNDILOGICAdd; dil++){
      for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){
        if(fpedQ0[nDDL][row][dil][pad]>0) outerr<< Form("%2d %2d %2d %3d\n",row,dil,pad,fpedQ0[nDDL][row][dil][pad]);
      }
    }
  } 
                                                                                                                                                                                       
                                                               
  outerr.close();                                                                                        //write error file
  return kTRUE;
    
}//FillErrors()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Bool_t AliHMPIDCalib::CalcPedestal(Int_t nDDL, Char_t* name, Int_t nEv)    
{
  //
  //Calculate pedestal for each pad  
  //Arguments: nDDL-DDL number, name of the pedestal file and number of the read events
  //Retutns: kTRUE/kFALSE
  //
  
   
  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?!  
  Double_t mean=0,sigma=0;
  Double_t qs2m=0,qsm2=0;
  ofstream out;                                           //to write the pedestal text files
  Int_t inhard;
  Int_t nEvPerPad=0;
  out.open(name);
  out << Form("%8s %2d\n","RunNumber",(Int_t)fRunNum);                                                //read run number
  out << Form("%8s %2d\n","LdcId" ,         fLdcId);                                                  //read LDC Id
  out << Form("%8s %2d\n","TimeStamp",      fTimeStamp);                                              //read time stamp
  out << Form("%8s %2d\n","TotNumEvt",      nEv);                                                     //read number of total events processed
  out << Form("%8s %2d\n","TotDDLEvt",      fnDDLInStream[nDDL]);                                     //read number of bad events for DDL # nDDL processed
  out << Form("%8s %2d\n","NumBadEvt",      fnDDLInStream[nDDL]-fnDDLOutStream[nDDL]);                //read number of bad events for DDL # nDDL processed
  out << Form("%8s %2f\n","NBadE(%)",       (fnDDLInStream[nDDL]-fnDDLOutStream[nDDL])*100.0/nEv);    //read number of bad events (in %) for DDL # nDDL processed
  out << Form("%8s %2.2d\n","#SigCut",      fSigCut);                                                 //# of sigma cuts
      
  for(Int_t row = 1; row <= AliHMPIDRawStream::kNRows; row++){
    for(Int_t dil = 1; dil <= AliHMPIDRawStream::kNDILOGICAdd; dil++){
      for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){
        
        mean  = 50;sigma = 100;
        
        nEvPerPad=fnpc[nDDL][row][dil][pad];
        
        
        if(nEvPerPad < 1 ) {                    //if the pad is bad then we assign 100  for the sigma and 50 for the mean
          mean  = 4000;
          sigma = 1000;
        }
        else{        
         mean = fsq[nDDL][row][dil][pad]*1.0/nEvPerPad;
         qs2m = fsq2[nDDL][row][dil][pad]*1.0/nEvPerPad;
         qsm2 = TMath::Power(fsq[nDDL][row][dil][pad]*1.0/nEvPerPad,2); 
        sigma = TMath::Sqrt(TMath::Abs(qs2m-qsm2));
        }
                
        inhard=((Int_t(mean))<<9)+Int_t(mean+3*sigma);
        out << Form("%2i %2i %2i %5.2f %5.2f %4.4x \n",row,dil,pad,mean,sigma,inhard);
                 
       //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]);
        
       
        }//adr
      }//dil
    }//row
    out.close();                                          //write pedestal file
  return kTRUE;
}//CaclPedestal()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Commit	Line	Data
21f61e25	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
3c8e86a0	17	#include "AliHMPIDParam.h" //class header
3c8e86a0	18	#include "AliHMPIDRawStream.h" //class header
21f61e25	19	#include <fstream>
21f61e25	20	#include <TTree.h>
0f1281b2	21
0f1281b2	22
21f61e25	23
	24	ClassImp(AliHMPIDCalib)
	25
	26
	27	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3c8e86a0	28	AliHMPIDCalib::AliHMPIDCalib():
3c8e86a0	29	faddl(0x0),
ee812b5b	30	fsq(0x0),
	31	fsq2(0x0),
	32	fnpc(0x0),
	33	fpedQ0(0x0),
	34	fErr(0x0),
3c8e86a0	35	fPadAdc(0x0),
	36	fIsPad(0x0),
	37	fFile(0x0),
	38	fLdcId(0),
	39	fTimeStamp(0),
	40	fRunNum(0),
	41	fSigCut(0),
ee812b5b	42	fWritePads(0),
	43	fnDDLInStream(0x0),
	44	fnDDLOutStream(0x0),
	45	fLargeHisto(kFALSE),
	46	fSelectDDL(0)
21f61e25	47	{
3e60bb92	48	//
	49	//constructor
	50	//
3c8e86a0	51	faddl = new Bool_t[AliHMPIDRawStream::kNDDL];
3c8e86a0	52	Int_t nPads = (AliHMPIDParam::kMaxCh+1)(AliHMPIDParam::kMaxPcx+1)(AliHMPIDParam::kMaxPcy+1);
ee812b5b	53
	54	fpedQ0 = new Int_t***[AliHMPIDRawStream::kNDDL+1];
	55	fsq2 = new Float_t ***[AliHMPIDRawStream::kNDDL+1];
	56	fsq = new Float_t ***[AliHMPIDRawStream::kNDDL+1];
	57	fnpc = new Int_t ***[AliHMPIDRawStream::kNDDL+1];
	58	fErr = new Int_t*[AliHMPIDRawStream::kNDDL+1];
	59
	60	fnDDLInStream = new Int_t[AliHMPIDRawStream::kNDDL+1];
	61	fnDDLOutStream = new Int_t[AliHMPIDRawStream::kNDDL+1];
	62
	63
	64	for(Int_t iDDL=0;iDDL<AliHMPIDRawStream::kNDDL+1;iDDL++) {
	65
	66	fErr[iDDL] = new Int_t[AliHMPIDRawStream::kSumErr+1];
	67	fpedQ0[iDDL] = new Int_t**[AliHMPIDRawStream::kNRows+1];
	68	fsq[iDDL] = new Float_t**[AliHMPIDRawStream::kNRows+1];
	69	fsq2[iDDL] = new Float_t**[AliHMPIDRawStream::kNRows+1];
	70	fnpc[iDDL] = new Int_t**[AliHMPIDRawStream::kNRows+1];
	71
	72	for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++) {
	73
	74	fpedQ0[iDDL][iRow] = new Int_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
	75	fsq[iDDL][iRow] = new Float_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
	76	fsq2[iDDL][iRow] = new Float_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
	77	fnpc[iDDL][iRow] = new Int_t*[AliHMPIDRawStream::kNDILOGICAdd+1];
	78
	79	for(Int_t iDil=1;iDil<AliHMPIDRawStream::kNDILOGICAdd+1;iDil++){
	80
	81	fpedQ0[iDDL][iRow][iDil] = new Int_t[AliHMPIDRawStream::kNPadAdd+1];
	82	fsq2[iDDL][iRow][iDil] = new Float_t[AliHMPIDRawStream::kNPadAdd+1];
	83	fsq[iDDL][iRow][iDil] = new Float_t[AliHMPIDRawStream::kNPadAdd+1];
	84	fnpc[iDDL][iRow][iDil] = new Int_t[AliHMPIDRawStream::kNPadAdd+1];
	85	}//iDil
	86	}//iRow
	87	}//iDDL
	88
	89	for(Int_t iDDL=0;iDDL<AliHMPIDRawStream::kNDDL+1;iDDL++) {
	90
	91	fnDDLInStream[iDDL]=-1;
	92	fnDDLOutStream[iDDL]=-1;
	93
	94	for(Int_t iErr=0;iErr<AliHMPIDRawStream::kSumErr+1;iErr++) {fErr[iDDL][iErr]=0;}
	95
	96	for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++) {
	97	for(Int_t iDil=1;iDil<AliHMPIDRawStream::kNDILOGICAdd+1;iDil++) {
	98	for(Int_t iPad=1;iPad<AliHMPIDRawStream::kNPadAdd+1;iPad++) {
	99	fpedQ0[iDDL][iRow][iDil][iPad]=0;
	100	fsq[iDDL][iRow][iDil][iPad]=0;
	101	fsq2[iDDL][iRow][iDil][iPad]=0;
	102	fnpc[iDDL][iRow][iDil][iPad]=0;
	103	}//iPad
	104	}//iDil
	105	}//iRow
	106	}//iDDL
	107
3c8e86a0	108	fPadAdc=new TH1I*[nPads];
	109	fIsPad=new Bool_t[nPads];
	110	for(Int_t np=0;np<nPads;np++) {fPadAdc[np]=0x0; fIsPad[np]=kFALSE;}
	111	fWritePads=kFALSE;
ee812b5b	112
ee812b5b	113
21f61e25	114	Init();
	115	}
	116	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	117	AliHMPIDCalib::~AliHMPIDCalib()
	118	{
3e60bb92	119	//
21f61e25	120	//destructor
3e60bb92	121	//
ee812b5b	122	if (faddl) { delete [] faddl; faddl = 0x0; }
	123	if (fPadAdc) { delete [] fPadAdc; fPadAdc=0x0; }
	124	if (fIsPad) { delete [] fIsPad; fIsPad=0x0; }
	125	if (fFile) { delete fFile; fFile=0x0; }
	126
	127	for(Int_t iErr=0;iErr<AliHMPIDRawStream::kSumErr+1;iErr++) { delete [] fErr[iErr];} delete [] fErr;
	128
	129	for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++)
	130	for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++)
	131	for(Int_t iDil=1;iDil<AliHMPIDRawStream::kNDILOGICAdd+1;iDil++)
	132	{
	133	delete [] fpedQ0[iDDL][iRow][iDil]; //del iPad
	134	delete [] fsq[iDDL][iRow][iDil]; //del iPad
	135	delete [] fsq2[iDDL][iRow][iDil]; //del iPad
	136	delete [] fnpc[iDDL][iRow][iDil]; //del iPad
	137	}
	138	for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++)
	139	for(Int_t iRow=0;iRow<AliHMPIDRawStream::kNRows+1;iRow++)
	140	{
	141	delete [] fpedQ0[iDDL][iRow]; //del iRow
	142	delete [] fsq[iDDL][iRow]; //del iRow
	143	delete [] fsq2[iDDL][iRow]; //del iRow
	144	delete [] fnpc[iDDL][iRow]; //del iRow
	145	}
	146
	147	for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++)
	148	{
	149	delete [] fpedQ0[iDDL]; //del iRow
	150	delete [] fsq2[iDDL]; //del iRow
	151	delete [] fsq[iDDL]; //del iRow
	152	delete [] fnpc[iDDL]; //del iRow
	153	}
	154
	155	delete [] fpedQ0;
	156	delete [] fsq2;
	157	delete [] fsq;
	158	delete [] fnpc;
	159
	160	fpedQ0=0;
	161	fsq2=0;
	162	fsq=0;
	163	fnpc=0;
	164
3c8e86a0	165	fLdcId=0;
	166	fTimeStamp=0;
	167	fRunNum=0;
	168	fSigCut=0;
	169	fWritePads=0;
ee812b5b	170	fLargeHisto=kFALSE;
ee812b5b	171	fSelectDDL=0;
3c8e86a0	172	}//dtor
21f61e25	173	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	174	void AliHMPIDCalib::Init()
	175	{
21f61e25	176	//
3e60bb92	177	//Init the q calc.
3c8e86a0	178	//Arguments: none
3c8e86a0	179	//Return: none
21f61e25	180	//
3c8e86a0	181	fSigCut=3;
3c8e86a0	182	for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++)
3e60bb92	183	{
3c8e86a0	184	for(Int_t ierr=0; ierr <AliHMPIDRawStream::kSumErr ; ierr++) {
	185	fErr[iDDL][ierr]=0;
	186	}
	187
3e60bb92	188	faddl[iDDL]=kFALSE;
ee812b5b	189	}//DDL
3e60bb92	190	}//Init()
21f61e25	191	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3c8e86a0	192	void AliHMPIDCalib::SetRunParams(ULong_t runNum,Int_t timeStamp, Int_t ldcId)
	193	{
	194	//
	195	//Set run parameters for the Pedestal and Error Files
	196	//Arguments: run number, time stamp and LDC Id
	197	//Returns: none
	198	//
	199	fRunNum=(Int_t)runNum;
	200	fTimeStamp=timeStamp;
	201	fLdcId=ldcId;
	202	}//SetRunParams()
	203	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	204	void AliHMPIDCalib::SetSigCutFromFile(Char_t* name)
21f61e25	205	{
21f61e25	206	//
3c8e86a0	207	//Set Sigma Cut from the file on the LDC, if the input file is not present default value is set!
	208	//Arguments: the name of the SigmaCut file on the LDC
	209	//Returns: none
	210	//
	211	Int_t nSigCut=0;
	212	ifstream infile(name);
	213	if(!infile.is_open()) {fSigCut=3; return;}
	214	while(!infile.eof())
	215	{
	216	infile>>nSigCut;
	217	}
	218	infile.close();
	219	fSigCut=nSigCut;
	220	}//SetSigCutFromFile()
	221	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	222	void AliHMPIDCalib::InitHisto(Int_t q,Int_t histocnt,Char_t* name)
	223	{
	224	//
	225	//Init the pad histos. For one DDL we have 11520 pads. ONLY if ENABLED!
	226	//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)
	227	//Returns: none
	228	//
ee812b5b	229	if(fWritePads==kFALSE) return;
3c8e86a0	230	fFile->cd();
3c8e86a0	231	Double_t lowbin,highbin=0;
ee812b5b	232	lowbin=q-40.5; highbin=q+40.5;
ee812b5b	233
3c8e86a0	234	if(fIsPad[histocnt]==kTRUE) return;
3c8e86a0	235
ee812b5b	236	if(fLargeHisto==kFALSE) fPadAdc[histocnt]=new TH1I(name,name,81,lowbin,highbin);
ee812b5b	237	if(fLargeHisto==kTRUE) fPadAdc[histocnt]=new TH1I(name,name,4093,-0.5,4092.5);
3c8e86a0	238	fPadAdc[histocnt]->Sumw2();
	239	fIsPad[histocnt]=kTRUE;
	240
	241	}//InitHisto()
	242	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	243	void AliHMPIDCalib::FillHisto(Int_t histocnt,Int_t q)
	244	{
	245	//
	246	//Fill the ADC histograms for each pad
	247	//Arguments: q-charge, the absolute number of the histogram (AliHMPIDParam::kMaxCh+1)(AliHMPIDParam::kMaxPcx+1)(AliHMPIDParam::kMaxPcy+1)
	248	//Returns: none
	249	//
3c8e86a0	250	if(fIsPad[histocnt]==kFALSE) return;
ee812b5b	251	fFile->cd();
3c8e86a0	252	fPadAdc[histocnt]->Fill(q);
	253
	254	}//InitHisto()
	255	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
77e40af5	256	void AliHMPIDCalib::InitFile(Int_t inVal)
3c8e86a0	257	{
	258	//
	259	//Initialize the ADC histo output file (one per LDC)
	260	//Arguments: LDC Id
	261	//Returns: none
	262	//
77e40af5	263	if(fWritePads==kFALSE ) return;
	264	if(fLargeHisto==kFALSE) fFile=new TFile(Form("HmpidPadsOnLdc%2d.root",inVal),"RECREATE");
	265	if(fLargeHisto==kTRUE) fFile=new TFile(Form("Run%d_DDL%d.root",inVal,fSelectDDL),"RECREATE");
	266
3c8e86a0	267	}//InitFile()
3c8e86a0	268	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
77e40af5	269	void AliHMPIDCalib::CloseFile()
3c8e86a0	270	{
	271	//
	272	//Close the ADC histo output file (one per LDC)
	273	//Arguments: LDC Id
	274	//Returns: none
	275	//
	276	fFile->cd();
	277	Int_t nPads = (AliHMPIDParam::kMaxCh+1)(AliHMPIDParam::kMaxPcx+1)(AliHMPIDParam::kMaxPcy+1);
	278	for(Int_t np=0;np<nPads;np++) {if(fIsPad[np]==kTRUE) fPadAdc[np]->Write();}
	279	fFile->Close();
	280	}//CloseFile()
	281	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	282	void AliHMPIDCalib::FillPedestal(Int_t abspad,Int_t q)
	283	{
	284	//
	285	//Called from the HMPIDda and fills the pedestal values
	286	//Arguments: absulote pad number as from AliHMPIDParam and q-charge
	287	//Returns: none
21f61e25	288	//
ee812b5b	289	if(q<0) AliFatal("Negative charge is read!!!!!!");
ee812b5b	290
0f1281b2	291	Int_t nDDL=0, row=0, dil=0, adr=0;
	292	//The decoding (abs. pad -> ddl,dil,...) is the same as in AliHMPIDDigit::Raw
	293	Int_t y2a[6]={5,3,1,0,2,4};
	294
3c8e86a0	295	nDDL= 2*AliHMPIDParam::A2C(abspad)+AliHMPIDParam::A2P(abspad)%2; //DDL# 0..13
77e40af5	296	Int_t tmp= 1+AliHMPIDParam::A2P(abspad)/2*8+AliHMPIDParam::A2Y(abspad)/6; //temp variable
77e40af5	297	row= (AliHMPIDParam::A2P(abspad)%2)? tmp:25-tmp; //row r=1..24
3c8e86a0	298	dil= 1+AliHMPIDParam::A2X(abspad)/8; //DILOGIC
3c8e86a0	299	adr=y2a[AliHMPIDParam::A2Y(abspad)%6]+6*(AliHMPIDParam::A2X(abspad)%8); //ADDRESS 0..47
0f1281b2	300	//........... decoding done
3e60bb92	301
77e40af5	302	// if(row<1 \|\| row > 24 \|\| nDDL < 0 \|\| nDDL > 13 \|\| dil < 1 \|\| dil > 10 \|\| adr < 0 \|\| adr >47) AliFatal(Form("ddl %d row %d dil %d adr %d",nDDL,row,dil,adr));
	303
	304
	305
ee812b5b	306	if(q>0) {
	307	fsq[nDDL][row][dil][adr]+=q;
	308	fsq2[nDDL][row][dil][adr]+=q*q;
	309	fnpc[nDDL][row][dil][adr]++; //Count how many times the pad is good (can be different from the good DDL count)
	310	faddl[nDDL]=kTRUE;
	311	}
	312	else
	313	{
	314	fpedQ0[nDDL][row][dil][adr]++; //Count how many times a pad charge is zero
3c8e86a0	315	}
ee812b5b	316
	317	Int_t histocnt=0; histocnt=(nDDL)11520+(row-1)480+(dil-1)*48+adr; //Histo counter for a single DDL
	318
	319	if(fWritePads==kTRUE) //works but make it nicer later....
	320	{
	321	if( fLargeHisto==kTRUE && nDDL==fSelectDDL) {
	322	InitHisto(q,histocnt,Form("hDDL_%d_Row_%d_Dil_%d_Pad_%d",nDDL,row,dil,adr)); //for large histos use hardware naming
	323	FillHisto(histocnt,q);
	324	}
	325	if(fLargeHisto==kFALSE)
	326	{
	327	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)));
	328	FillHisto(histocnt,q);
	329	}
	330	}//fWritePads
3c8e86a0	331
21f61e25	332	}//FillPedestal()
21f61e25	333	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3c8e86a0	334	void AliHMPIDCalib::FillErrors(Int_t nDDL,Int_t eType, Int_t nErr)
0f1281b2	335	{
0f1281b2	336	//
3c8e86a0	337	//Fill decoding errors from AliHMPIDRawStream
	338	//Arguments: nDDL-DDL number, eType- error type as in AliHMPIDRawStream.h and the # of occurence for eType
	339	//Retutns: none
0f1281b2	340	//
3c8e86a0	341	if(nErr<=0) return;
	342	if(eType < 0 \|\| eType> AliHMPIDRawStream::kSumErr ) return;
	343	fErr[nDDL][eType]=fErr[nDDL][eType]+nErr;
ee812b5b	344
0f1281b2	345
	346	}//FillErrors()
	347	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ee812b5b	348	void AliHMPIDCalib::FillDDLCnt(Int_t iddl,Int_t inDDL, Int_t outDDL)
	349	{
	350	//
	351	//Fill decoding DDL check from RawStream
	352	//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
	353	//Retutns: none
	354	//
	355
	356	if(inDDL==-1) return;
	357	if(fnDDLInStream[iddl]==-1) {fnDDLInStream[iddl]=0; fnDDLOutStream[iddl]=0;}
	358	fnDDLInStream[iddl]+=inDDL;
	359	fnDDLOutStream[iddl]+=outDDL;
	360
	361
	362	}//FillDDLCnt()
	363	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3c8e86a0	364	Bool_t AliHMPIDCalib::WriteErrors(Int_t nDDL, Char_t* name, Int_t nEv)
0f1281b2	365	{
	366	//
	367	//Write decoding errors to a txt file
3c8e86a0	368	//Arguments: nDDL-DDL number, name of the error file and number of the read events
3c8e86a0	369	//Retutns: kTRUE/kFALSE
0f1281b2	370	//
0f1281b2	371
ee812b5b	372	if(faddl[nDDL]==kFALSE) return kFALSE; //if ddl is missing no error file is created
	373	ofstream outerr; outerr.open(name); //open error file
	374	outerr << Form("%8s %2d\n","RunNumber",(Int_t)fRunNum); //read run number
	375	outerr << Form("%8s %2d\n","LdcId" , fLdcId); //read LDC Id
	376	outerr << Form("%8s %2d\n","TimeStamp", fTimeStamp); //read time stamp
	377	outerr << Form("%8s %2d\n","TotNumEvt", nEv); //read number of total events processed
	378	outerr << Form("%8s %2d\n","TotDDLEvt", fnDDLInStream[nDDL]); //read number of bad events for DDL # nDDL processed
	379	outerr << Form("%8s %2d\n","NumBadEvt", fnDDLInStream[nDDL]-fnDDLOutStream[nDDL]); //read number of bad events for DDL # nDDL processed
	380	outerr << Form("%8s %2.2f\n","NBadE(%)", (fnDDLInStream[nDDL]-fnDDLOutStream[nDDL])*100.0/nEv); //read number of bad events (in %) for DDL # nDDL processed
	381
3c8e86a0	382	for(Int_t ierr=0; ierr <AliHMPIDRawStream::kSumErr; ierr++) outerr << Form("%2d\t",fErr[nDDL][ierr]); //write errors
3c8e86a0	383	outerr << Form("\n"); //last break
77e40af5	384	/* write out pads with 0 charge read */
	385	for(Int_t row = 1; row <= AliHMPIDRawStream::kNRows; row++){
	386	for(Int_t dil = 1; dil <= AliHMPIDRawStream::kNDILOGICAdd; dil++){
	387	for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){
	388	if(fpedQ0[nDDL][row][dil][pad]>0) outerr<< Form("%2d %2d %2d %3d\n",row,dil,pad,fpedQ0[nDDL][row][dil][pad]);
	389	}
	390	}
	391	}
	392
	393
3c8e86a0	394	outerr.close(); //write error file
0f1281b2	395	return kTRUE;
	396
	397	}//FillErrors()
	398	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3c8e86a0	399	Bool_t AliHMPIDCalib::CalcPedestal(Int_t nDDL, Char_t* name, Int_t nEv)
21f61e25	400	{
	401	//
	402	//Calculate pedestal for each pad
3c8e86a0	403	//Arguments: nDDL-DDL number, name of the pedestal file and number of the read events
3c8e86a0	404	//Retutns: kTRUE/kFALSE
21f61e25	405	//
3c8e86a0	406
0f1281b2	407
0f1281b2	408	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?!
ee812b5b	409	Double_t mean=0,sigma=0;
ee812b5b	410	Double_t qs2m=0,qsm2=0;
21f61e25	411	ofstream out; //to write the pedestal text files
21f61e25	412	Int_t inhard;
ee812b5b	413	Int_t nEvPerPad=0;
3e60bb92	414	out.open(name);
ee812b5b	415	out << Form("%8s %2d\n","RunNumber",(Int_t)fRunNum); //read run number
	416	out << Form("%8s %2d\n","LdcId" , fLdcId); //read LDC Id
	417	out << Form("%8s %2d\n","TimeStamp", fTimeStamp); //read time stamp
	418	out << Form("%8s %2d\n","TotNumEvt", nEv); //read number of total events processed
	419	out << Form("%8s %2d\n","TotDDLEvt", fnDDLInStream[nDDL]); //read number of bad events for DDL # nDDL processed
	420	out << Form("%8s %2d\n","NumBadEvt", fnDDLInStream[nDDL]-fnDDLOutStream[nDDL]); //read number of bad events for DDL # nDDL processed
	421	out << Form("%8s %2f\n","NBadE(%)", (fnDDLInStream[nDDL]-fnDDLOutStream[nDDL])*100.0/nEv); //read number of bad events (in %) for DDL # nDDL processed
	422	out << Form("%8s %2.2d\n","#SigCut", fSigCut); //# of sigma cuts
	423
3c8e86a0	424	for(Int_t row = 1; row <= AliHMPIDRawStream::kNRows; row++){
	425	for(Int_t dil = 1; dil <= AliHMPIDRawStream::kNDILOGICAdd; dil++){
	426	for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){
3e60bb92	427
ee812b5b	428	mean = 50;sigma = 100;
3e60bb92	429
ee812b5b	430	nEvPerPad=fnpc[nDDL][row][dil][pad];
3e60bb92	431
ee812b5b	432
ee812b5b	433	if(nEvPerPad < 1 ) { //if the pad is bad then we assign 100 for the sigma and 50 for the mean
9f99568d	434	mean = 4000;
9f99568d	435	sigma = 1000;
ee812b5b	436	}
	437	else{
	438	mean = fsq[nDDL][row][dil][pad]*1.0/nEvPerPad;
	439	qs2m = fsq2[nDDL][row][dil][pad]*1.0/nEvPerPad;
	440	qsm2 = TMath::Power(fsq[nDDL][row][dil][pad]*1.0/nEvPerPad,2);
	441	sigma = TMath::Sqrt(TMath::Abs(qs2m-qsm2));
	442	}
	443
3e60bb92	444	inhard=((Int_t(mean))<<9)+Int_t(mean+3*sigma);
ee812b5b	445	out << Form("%2i %2i %2i %5.2f %5.2f %4.4x \n",row,dil,pad,mean,sigma,inhard);
	446
	447	//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]);
	448
	449
21f61e25	450	}//adr
	451	}//dil
	452	}//row
	453	out.close(); //write pedestal file
	454	return kTRUE;
	455	}//CaclPedestal()
	456	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ee812b5b	457