Additions in QA (according to Yves) + improvements
authordibari <dibari@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Aug 2009 11:13:34 +0000 (11:13 +0000)
committerdibari <dibari@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Aug 2009 11:13:34 +0000 (11:13 +0000)
HMPID/AliHMPIDCalib.cxx
HMPID/AliHMPIDCalib.h
HMPID/AliHMPIDDigit.cxx
HMPID/AliHMPIDDigit.h
HMPID/AliHMPIDParam.h
HMPID/AliHMPIDQAChecker.cxx
HMPID/AliHMPIDQAChecker.h
HMPID/AliHMPIDRawStream.h
HMPID/HMPIDda.cxx

index 95c1f88..e51c97a 100644 (file)
@@ -44,15 +44,20 @@ fLdcId(0),
 fTimeStamp(0),
 fRunNum(0),
 fSigCut(0),
-fWritePads(0),
 fnDDLInStream(0x0),
 fnDDLOutStream(0x0),
 fLargeHisto(kFALSE),
-fSelectDDL(0)
+fSelectDDL(0),
+fDeadMap(0x0),
+fPedMeanMap(0x0),
+fPedSigMap(0x0),
+f1DPedMean(0x0),
+f1DPedSigma(0x0)
 {
   //
   //constructor
   //
+  
   faddl = new Bool_t[AliHMPIDRawStream::kNDDL];
   Int_t nPads =  (AliHMPIDParam::kMaxCh+1)*(AliHMPIDParam::kMaxPcx+1)*(AliHMPIDParam::kMaxPcy+1);
  
@@ -113,8 +118,6 @@ fSelectDDL(0)
   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();
 }
@@ -128,7 +131,8 @@ AliHMPIDCalib::~AliHMPIDCalib()
   if (fPadAdc)   { delete [] fPadAdc; fPadAdc=0x0;  }  
   if (fIsPad)    { delete [] fIsPad;  fIsPad=0x0;   }  
   if (fFile)     { delete    fFile;   fFile=0x0;    }  
+  if (fDeadMap)  { delete    fDeadMap;fDeadMap=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++) 
@@ -171,9 +175,14 @@ AliHMPIDCalib::~AliHMPIDCalib()
   fTimeStamp=0;
   fRunNum=0;
   fSigCut=0;
-  fWritePads=0;
   fLargeHisto=kFALSE;
   fSelectDDL=0;
+  
+  if (fPedMeanMap)   { delete [] fPedMeanMap; fPedMeanMap=0x0;  }  
+  if (fPedSigMap)    { delete [] fPedSigMap;  fPedSigMap=0x0;   }  
+  if (f1DPedMean)    { delete [] f1DPedMean;  f1DPedMean=0x0;   }
+  if (f1DPedSigma)   { delete [] f1DPedSigma; f1DPedSigma=0x0;  }
+  
 }//dtor
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 void AliHMPIDCalib::Init()
@@ -185,7 +194,8 @@ void AliHMPIDCalib::Init()
   //
     
   fSigCut=3;  //the standard cut
-       
+
   for(Int_t iDDL=0; iDDL< AliHMPIDRawStream::kNDDL; iDDL++) 
       {
          for(Int_t ierr=0; ierr <AliHMPIDRawStream::kSumErr ; ierr++) {
@@ -194,6 +204,32 @@ void AliHMPIDCalib::Init()
         
         faddl[iDDL]=kFALSE;
       }//DDL
+      
+     Int_t      nbins[4]={14, 24, 10, 48};
+     Double_t  binmin[4]={ 0,  1,  1,  0};
+     Double_t  binmax[4]={14, 25, 11, 48};
+     fDeadMap = new THnSparseD("fDeadMap","Dead Channel Map",4,nbins,binmin,binmax); 
+     
+   fPedMeanMap = new TH2F*[AliHMPIDParam::kMaxCh+1];
+   fPedSigMap  = new TH2F*[AliHMPIDParam::kMaxCh+1];
+   f1DPedMean  = new TH1F*[(AliHMPIDParam::kMaxCh+1)*(AliHMPIDParam::kMaxPc+1)];
+   f1DPedSigma = new TH1F*[(AliHMPIDParam::kMaxCh+1)*(AliHMPIDParam::kMaxPc+1)];
+   
+   Int_t mapmin,mapmax;
+   for(Int_t iCh=0;iCh<AliHMPIDParam::kMaxCh+1;iCh++)  
+   {
+    fPedMeanMap[iCh]=new TH2F(Form("fPedMeanMap%d",iCh),Form("fPedMeanMap%d;pad x;pad y;Mean pedestal (ADC)",iCh),160, 0,160,144,0,144);fPedMeanMap[iCh]->SetStats(kFALSE);
+    fPedSigMap[iCh] =new TH2F(Form("fPedSigMap%d",iCh), Form("fPedSigMap%d;pad x;pad y;Sigma pedestal (ADC)",iCh), 160, 0,160,144,0,144);fPedSigMap[iCh]->SetStats(kFALSE);
+   }
+   for(Int_t iCh=0;iCh<=AliHMPIDParam::kMaxCh;iCh++)
+   {
+    for(Int_t iFee=0;iFee<6;iFee++)
+     {
+      f1DPedMean[6*iCh+iFee]  = new TH1F(Form("f1DPedMean_Ch%d_FEE_%d" , iCh,iFee),Form("Mean Pedestals, RICH %d, FEE %d;Channels;Mean pedestal (ADC)" ,iCh,iFee),3840,0,3840);f1DPedMean[6*iCh+iFee]->SetStats(kFALSE);
+      f1DPedSigma[6*iCh+iFee] = new TH1F(Form("f1DPedSigma_Ch%d_FEE_%d" ,iCh,iFee),Form("Sigma Pedestal, RICH %d, FEE %d;Channels;Sigma pedestal (ADC)" ,iCh,iFee),3840,0,3840);f1DPedSigma[6*iCh+iFee]->SetStats(kFALSE);
+     } 
+   }
+     
 }//Init()
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 void AliHMPIDCalib::SetRunParams(ULong_t runNum,Int_t timeStamp, Int_t ldcId)
@@ -228,65 +264,36 @@ void AliHMPIDCalib::SetSigCutFromFile(TString hmpInFile)
   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)
+void AliHMPIDCalib::SetDeadChannelMapFromFile(TString hmpInFile)
 {
   //
-  //Initialize the ADC histo output file (one per LDC)
-  //Arguments: LDC Id
+  //Set Dead Channel Map Cut from the file on the LDC, if the input file is not present default value is set!
+  //Arguments: the name of the Dead Channel Map file on the LDC
   //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"); 
+  Char_t header[256];
+  Int_t ddl=0,row=0,dil=0,pad=0,ch=0,pc=0,chpadx=0,chpady=0,px=0,py=0,isitmasked=0;
+  UInt_t dw=0;
+  Double_t bin[4];
+  ifstream infile(hmpInFile.Data());
+  if(!infile.is_open()) {Printf("HMPID Dead Channel Map file cannot be opened!!!! No mask is applied!!!");return;}
+  infile.getline(header,256);
+  AliHMPIDDigit dig;
+  while(!infile.eof())
+    {
+    infile>>ch>>chpadx>>chpady>>isitmasked;                     //read in masked coordinates; coordinates are in the module coordinate system
+    pc=(chpadx/80)+2*(chpady/48);                               //get PC number
+    px=chpadx-80*(chpadx/80);                                   //get pad X in PC coordinates
+    py=chpady-48*(chpady/48);                                   //get pad Y in PC coordinates --- can we do it better??? -- just with one conversion???? clm
+    if(!dig.Set(ch,pc,px,py,0) && isitmasked) {                 //in the AliHMPIDDigit:Set there is already a check if the coordinates makes sense
+       dig.Raw(dw,ddl,row,dil,pad);
+       bin[0]=ddl; bin[1]=row; bin[2]=dil; bin[3]=pad;
+       fDeadMap->Fill(bin,1);
+      }
+    }
+   infile.close();
   
-}//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()
+}//SetDeadChannelMapFromFile()
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 void AliHMPIDCalib::FillPedestal(Int_t abspad,Int_t q)
 {
@@ -320,20 +327,7 @@ void AliHMPIDCalib::FillPedestal(Int_t abspad,Int_t q)
       }
       
      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)
@@ -419,6 +413,10 @@ Bool_t AliHMPIDCalib::CalcPedestal(Int_t nDDL, Char_t* name, Char_t *name2,Int_t
   ofstream out;                                            //to write the pedestal text files
   Int_t inhard;
   Int_t nEvPerPad=0;
+  Int_t pedbin=0;
+  
+  Int_t abspad,ch,pc,pcx,pcy,chX,chY,fee;
+  Int_t binSp[4]={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
@@ -427,7 +425,7 @@ Bool_t AliHMPIDCalib::CalcPedestal(Int_t nDDL, Char_t* name, Char_t *name2,Int_t
   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 %d\n","#SigCut",      fSigCut);                                                 //# of sigma cuts
+  out << Form("%8s %d\n","#SigCut",      fSigCut);                                                    //# of sigma cuts
       
   for(Int_t row = 1; row <= AliHMPIDRawStream::kNRows; row++){
     feeInput << Form("0xabcdabcd \n");                                                                    //before each row we write a marker to separate the rows within a DDL                       
@@ -435,29 +433,51 @@ Bool_t AliHMPIDCalib::CalcPedestal(Int_t nDDL, Char_t* name, Char_t *name2,Int_t
    
     for(Int_t dil = 1; dil <= AliHMPIDRawStream::kNDILOGICAdd; dil++){
       for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){
+        mean  = 50;sigma = 100;                                                   //init maen and sigma to a low value
+        nEvPerPad=fnpc[nDDL][row][dil][pad];                                      //check how many times the pad was read out
+        abspad=AliHMPIDRawStream::GetPad(nDDL,row,dil,pad);                       //get the absolute oad coordinate
+        ch=AliHMPIDParam::A2C(abspad);                                            //get chamber number
+        pc=AliHMPIDParam::A2P(abspad);                                            //get PC number
+        pcx=AliHMPIDParam::A2X(abspad);                                           //get pad x in PC
+        pcy=AliHMPIDParam::A2Y(abspad);                                           //get pad y in PC
+        chX = (pc%2)*AliHMPIDParam::kPadPcX+pcx;                                  //get pad x in Ch   
+        chY = (pc/2)*AliHMPIDParam::kPadPcY+pcy;                                  //get pad y in Ch
+        binSp[0]=nDDL+1;binSp[1]=row;binSp[2]=dil;binSp[3]=pad+1;                 //set dead map coordinates for check
         
-        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;
+       if(nEvPerPad < 1 ) {                                                      //if the pad is bad then we assign 100  for the sigma and 50 for the mean
+          mean  = AliHMPIDParam::kPadMeanZeroCharge;
+          sigma = AliHMPIDParam::kPadSigmaZeroCharge;
         }
-        else{        
+        else if(fDeadMap->GetBinContent(binSp)>0)                                 //check if channel is masked, if yes set maksed values
+        {
+          mean  = AliHMPIDParam::kPadMeanMasked;
+          sigma = AliHMPIDParam::kPadSigmaMasked;
+        }
+       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+fSigCut*sigma))<<9)+Int_t(mean); //right calculation, xchecked with Paolo 8/4/2008
+        inhard=((Int_t(mean+fSigCut*sigma))<<9)+Int_t(mean);                       //right calculation, xchecked with Paolo 8/4/2008
         out << Form("%2i %2i %2i %5.3f %5.3f %4.4x \n",row,dil,pad,mean,sigma,inhard);
-
-        feeInput << Form("0x%4.4x\n",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
+        feeInput << Form("0x%4.4x\n",inhard);
         
+        // fill histograms to be exported to AMORE    
+        fPedMeanMap[ch]->SetTitle(Form("PedMeanMap%d RunNum: %d",ch,fRunNum));
+        fPedSigMap[ch]->SetTitle(Form("PedSigmaMap%d RunNum: %d",ch,fRunNum));
+        fPedMeanMap[ch]->Fill(chX,chY,mean);         
+        fPedSigMap[ch]->Fill(chX,chY,sigma);         
+        if(nDDL%2==0) pedbin = (24-row)*2*480+(10-dil)*48+pad;
+        if(nDDL%2!=0) pedbin = (row*2-1)*480+(10-dil)*48+pad;
+        pedbin = pedbin - 3840*(pedbin/3840);
+        fee=AliHMPIDRawStream::GetFee(nDDL,row);
+        f1DPedMean[6*(nDDL/2)+fee]->SetTitle(Form("PedMean_Ch%d_FEE_%d RunNum: %d",ch,fee,fRunNum));
+        f1DPedSigma[6*(nDDL/2)+fee]->SetTitle(Form("PedSigma_Ch%d_FEE_%d RunNum: %d",ch,fee,fRunNum));
+        f1DPedMean[6*(nDDL/2)+fee]->Fill(pedbin,mean);
+        f1DPedSigma[6*(nDDL/2)+fee]->Fill(pedbin,sigma);
+
+        }//adr==pad
         //we have to write up to 64 not 48 in the DILOGIC since they are daisy chained!
         //offset and format is defined for the Fe2C code
         for(Int_t idd=0;idd<16;idd++) feeInput << Form("0x%4.4x\n",idd+feeOffset);                 
@@ -471,65 +491,3 @@ Bool_t AliHMPIDCalib::CalcPedestal(Int_t nDDL, Char_t* name, Char_t *name2,Int_t
   return kTRUE;
 }//CaclPedestal()
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-Bool_t AliHMPIDCalib::CalcPedestalPaolo(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
-  //
-  //----------------- write files in the format of Paolo -----------------------
-  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?!  
-  Int_t ddlOffset=1536;
-  Int_t cnt=0;
-  Double_t mean1=0,sigma1=0;
-  Double_t qs2m1=0,qsm21=0;
-  Double_t mean2=0,sigma2=0;
-  Double_t qs2m2=0,qsm22=0;
-  Int_t nEvPerPad1=0;
-  Int_t nEvPerPad2=0;
-    
-  ofstream pped[3]; 
-  for(Int_t iseg=1;iseg<4;iseg++) pped[iseg-1].open(Form("HmpidPed%d_%d.dat",nDDL+ddlOffset,iseg));
-    
-  for(Int_t row = 1; row <= AliHMPIDRawStream::kNRows/2; row++){
-     
-      //write header
-      pped[(row-1)/4]<<Form("ID_Nevt_NChan_Row_Row_P0_P1_S0_S1 \n");
-      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);
-       
-      cnt=0; 
-      for(Int_t dil = 1; dil <= AliHMPIDRawStream::kNDILOGICAdd; dil++){
-      for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){
-        
-         nEvPerPad1=fnpc[nDDL][2*row-1][dil][pad];
-         nEvPerPad2=fnpc[nDDL][2*row][dil][pad];
-        
-        if(nEvPerPad1 < 1 ) { mean1  = 4000; sigma1 = 1000; }
-        else 
-        {
-          mean1 = fsq[nDDL][2*row-1][dil][pad]*1.0/nEvPerPad1;
-          qs2m1 = fsq2[nDDL][2*row-1][dil][pad]*1.0/nEvPerPad1;
-          qsm21 = TMath::Power(fsq[nDDL][2*row-1][dil][pad]*1.0/nEvPerPad1,2); 
-         sigma1 = TMath::Sqrt(TMath::Abs(qs2m1-qsm21));
-        }
-        
-        if(nEvPerPad2 < 1 ) { mean2  = 4000; sigma2 = 1000; }
-        else
-        {        
-         mean2 = fsq[nDDL][2*row][dil][pad]*1.0/nEvPerPad2;
-         qs2m2 = fsq2[nDDL][2*row][dil][pad]*1.0/nEvPerPad2;
-         qsm22 = TMath::Power(fsq[nDDL][2*row][dil][pad]*1.0/nEvPerPad2,2); 
-        sigma2 = TMath::Sqrt(TMath::Abs(qs2m2-qsm22));
-      }
-        pped[(row-1)/4]<<Form("%d %3.3lf %3.3lf %3.3lf %3.3lf \n",cnt,mean1,sigma1,mean2,sigma2);cnt++;
-      }//pad
-      }//dil 
-     }//row    
-    for(Int_t ir=0;ir<3;ir++) {pped[ir].close();    }  
-   return kTRUE;
-}//CalcPedestalPaolo()
-//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-
-
index b2c14d8..03d85f6 100644 (file)
@@ -16,6 +16,7 @@
 #include <TMath.h>
 #include <TFile.h>
 #include <TString.h>
+#include <THnSparse.h>
 #include "AliHMPIDParam.h"
 #include "AliHMPIDRawStream.h"
 
@@ -31,21 +32,18 @@ public:
           void FillErrors(Int_t nDDL,Int_t nErrType, Int_t nErr);           //Fill the errors from RawStream
           void FillDDLCnt(Int_t iddl,Int_t inDDL, Int_t outDDL);            //Fill the errors from RawStream
         Bool_t CalcPedestal(Int_t nDDL, Char_t* name, Char_t *name2,Int_t nEv);           //number of the DDL, name of the output file and the number of events processed
-        Bool_t CalcPedestalPaolo(Int_t nDDL, Char_t* name, Int_t nEv);      //number of the DDL, name of the output file and the number of events processed
         
         Bool_t WriteErrors(Int_t nDDL, Char_t* name, Int_t nEv);            //number of the DDL, name of the output file and the number of events processed
-         void InitHisto(Int_t q,Int_t histocnt,Char_t* name);               //Init the pad histograms
-         void FillHisto(Int_t histocnt,Int_t q);                            //Fill the ADC histograms
-         void InitFile(Int_t inVal);                                        //Init the ADC histo output file (one per LDC or one per DDL)
-         void CloseFile();                                                  //Close the file
          void SetRunParams(ULong_t runNum,Int_t timeStamp, Int_t ldcId);    //Set Run Parameters such as Run Number, TimeStamp, LDCid 
          void SetSigCut(Int_t nSigCut) { fSigCut=nSigCut;}                  //Set Sigma Cuts from Setter
          void SetSigCutFromFile(TString name);                              //Set Sigma Cuts from File
-         void SetWriteHistoPads(Bool_t isOn) {fWritePads=isOn;}             //Set wether ADC histos of pads are written or not
-         void SetWriteHistoPads(Bool_t isOn,Bool_t isLarge,Int_t nDDL) {fWritePads=isOn;fLargeHisto=isLarge;fSelectDDL=nDDL;}             //Set wether ADC histos of pads are written or not
-         Bool_t GetWritePads()       const{return fWritePads;}              //Set wether ADC histos of pads are written or not
-         Bool_t GetLargePads()       const{return fLargeHisto;}             //Set wether ADC histos of pads are written or not
-         Bool_t GetSelectedDDL()     const{return fSelectDDL;}              //Set wether ADC histos of pads are written or not
+         void SetDeadChannelMapFromFile(TString name);
+         Bool_t GetSelectedDDL()     const  {return fSelectDDL;}              //Set wether ADC histos of pads are written or not
+         TH2F   *GetPedMeanMap(Int_t iDDL)  {return fPedMeanMap[iDDL];}
+         TH2F   *GetPedSigMap(Int_t iDDL)   {return fPedSigMap[iDDL];}
+         TH1F   *GetPedMean(Int_t iChFee)   {return f1DPedMean[iChFee];}
+         TH1F   *GetPedSigma(Int_t iChFee)  {return f1DPedSigma[iChFee];}
+     THnSparse  *GetDeadMap()               {return fDeadMap;}
 protected: 
 
     Bool_t     *faddl;                                                         //check is ddl is filled
@@ -61,17 +59,22 @@ protected:
     UInt_t      fTimeStamp;                                                    //Time Stamp
     Int_t       fRunNum;                                                       //Run Number
     Int_t       fSigCut;                                                       //n. of pedestal distribution sigmas used to create zero suppresion table                          
-    Bool_t      fWritePads;                                                    //Select wether to write ADC pad histograms or not
     Int_t      *fnDDLInStream;                                                 // if the DDL is in the raw data
     Int_t      *fnDDLOutStream;                                                // if the DDL is in the raw data
     Bool_t      fLargeHisto;                                                   //Default is kFALSE.if kTRUE then write large pad histograms with 4093 bins!!!! Only if you have 2GB of RAM!!!   
     Int_t       fSelectDDL;                                                    //Select the DDL to write for the in the large histograms. Only ONE at one time!
-
-private:
-  AliHMPIDCalib(const AliHMPIDCalib& c);              //dummy copy constructor
-  AliHMPIDCalib &operator=(const AliHMPIDCalib& c);   //dummy assignment operator
-    
-    ClassDef(AliHMPIDCalib,3)                                                  //HMPID calibration and pedestal class        
+    THnSparse  *fDeadMap;                                                      //Dead Channel Map
+    TH2F       **fPedMeanMap;                                                  //2D mean pedestal map to export to AMORE
+    TH2F       **fPedSigMap;                                                   //2D pedestal sigma map to export to AMORE
+    TH1F      **f1DPedMean;                                                   //1D mean pedestal map to export to AMORE
+    TH1F      **f1DPedSigma;                                                   //1D pedestal sigma map to export to AMORE
+        
+  private:
+                                           
+  AliHMPIDCalib(const AliHMPIDCalib& c);                                       //dummy copy constructor
+  AliHMPIDCalib &operator=(const AliHMPIDCalib& c);                            //dummy assignment operator
+     
+    ClassDef(AliHMPIDCalib,4)                                                  //HMPID calibration and pedestal class        
 };
 #endif
 
index 80d3670..712a217 100644 (file)
@@ -28,7 +28,7 @@ ClassImp(AliHMPIDDigit)
 /*
  Preface: all geometrical information (like left-right sides) is reported as seen from electronic side.
  
-      d1          d10    d1           d10 
+      d10          d1    d10           d1 
       _______________    _______________          
 r1   |               |  |               |126.16   r24
      |       4       |  |       5       | 
@@ -44,7 +44,7 @@ r1   |               |  |               |126.16   r24
      |       0       |  |       1       |
      |               |  |               |
 r24  |_______________|  |_______________|0        r1        //updated: 15/02/2008
-      0           64.0  66.6        130.6 
+      0           64.0  66.6        130.6                   //corrected: 05/08/2009 clm
 
 
 
index de3b651..6b7f300 100644 (file)
@@ -173,16 +173,12 @@ void AliHMPIDDigit::Raw(UInt_t &w32,Int_t &ddl,Int_t &r,Int_t &d,Int_t &a)const
   a=y2a[PadPcY()%6]+6*(7-PadPcX()%8);   //ADDRESS 0..47        
     
   w32=0;   
-  //Printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
-  //
-  //Printf("AliHMPIDDigit::Raw ddl: %d r: %d d: %d a: %d",ddl,r,d,a);
-  //Printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
-//  Bool_t isOK=kTRUE; isOK=
+  if(r<1 || r>24 || d<1 || d>10 || a<0 || a>47) {w32=0;ddl=-1;r=-1;d=-1;a=-1; return;}    //clm: the assert is removed not to break the reconstruction code 
   AliBitPacking::PackWord((UInt_t)fQ,w32, 0,11);                      // 0000 0rrr rrdd ddaa aaaa qqqq qqqq qqqq        Qdc               bits (00..11) counts (0..4095)
-  assert(0<=a&&a<=47);AliBitPacking::PackWord(        a ,w32,12,17);  // 3322 2222 2222 1111 1111 1000 0000 0000        DILOGIC address   bits (12..17) counts (0..47)
-  assert(1<=d&&d<=10);AliBitPacking::PackWord(        d ,w32,18,21);  // 1098 7654 3210 9876 5432 1098 7654 3210        DILOGIC number    bits (18..21) counts (1..10)
-  assert(1<=r&&r<=24);AliBitPacking::PackWord(        r ,w32,22,26);  //                                                Row number        bits (22..26) counts (1..24)  
-                      AliBitPacking::PackWord((UInt_t)0, w32,27,27);  //To make sure set the 27th bit to Zero so we can distinguis it from the EoE
+  AliBitPacking::PackWord(        a ,w32,12,17);                      // 3322 2222 2222 1111 1111 1000 0000 0000        DILOGIC address   bits (12..17) counts (0..47)
+  AliBitPacking::PackWord(        d ,w32,18,21);                      // 1098 7654 3210 9876 5432 1098 7654 3210        DILOGIC number    bits (18..21) counts (1..10)
+  AliBitPacking::PackWord(        r ,w32,22,26);                      //                                                Row number        bits (22..26) counts (1..24)  
+  AliBitPacking::PackWord((UInt_t)0, w32,27,27);                      //To make sure set the 27th bit to Zero so we can distinguis it from the EoE
 }
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 Bool_t AliHMPIDDigit::Set(Int_t ch,Int_t pc,Int_t px,Int_t py,Int_t tid)
@@ -190,8 +186,11 @@ Bool_t AliHMPIDDigit::Set(Int_t ch,Int_t pc,Int_t px,Int_t py,Int_t tid)
 // Manual creation of digit
 // Arguments: ch,pc,px,py,qdc,tid  
 //   Returns: kTRUE if wrong digit
+  if(ch<AliHMPIDParam::kMinCh || ch>AliHMPIDParam::kMaxCh) return kTRUE;
+  if(pc<AliHMPIDParam::kMinPc || pc>AliHMPIDParam::kMaxPc) return kTRUE;
   if(px<AliHMPIDParam::kMinPx || px>AliHMPIDParam::kMaxPx) return kTRUE;
   if(py<AliHMPIDParam::kMinPy || py>AliHMPIDParam::kMaxPy) return kTRUE;
+  
 
   fPad=AliHMPIDParam::Abs(ch,pc,px,py);fTracks[0]=tid;
   fQ=0;
index cae9f7c..96a4e9f 100644 (file)
@@ -29,7 +29,8 @@ public:
   enum EChamberData{kMinCh=0,kMaxCh=6,kMinPc=0,kMaxPc=5};      //Segmenation
   enum EPadxData{kPadPcX=80,kMinPx=0,kMaxPx=79,kMaxPcx=159};   //Segmentation structure along x
   enum EPadyData{kPadPcY=48,kMinPy=0,kMaxPy=47,kMaxPcy=143};   //Segmentation structure along y 
-
+  enum EPedestalData{kPadMeanZeroCharge=4000,kPadSigmaZeroCharge=1000,kPadMeanMasked=4001,kPadSigmaMasked=1001}; //Pedestal pad data information
+      
   static Float_t SizePadX    (                               )     {return fgCellX;                                  }  //pad size x, [cm]  
   static Float_t SizePadY    (                               )     {return fgCellY;                                  }  //pad size y, [cm]  
 
index d6f2110..4ad7d09 100644 (file)
 
 ClassImp(AliHMPIDQAChecker)
 
+//____________________________________________________________________________
+Double_t * AliHMPIDQAChecker::Check(AliQAv1::ALITASK_t index)
+{
+  
+ TObjArray **list;
+
+  Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
+ Int_t count[AliRecoParam::kNSpecies]   = { 0 }; 
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++){ // species loop 
+    rv[specie] = 1.0 ; 
+   TObjArray *dataList;  Int_t iList=0;  
+  
+   if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
+   continue ; 
+   if (!fDataSubDir) {
+     rv[specie] = 0. ; // nothing to check
+   } 
+    else if (!fRefSubDir && !fRefOCDBSubDir) {
+        rv[specie] = -1 ; // no reference data
+    } 
+    else {
+      TList * keyList = fDataSubDir->GetListOfKeys() ; 
+      TIter next(keyList) ; 
+      TKey * key ;
+      count[specie] = 0 ; 
+      while ( (key = static_cast<TKey *>(next())) ) {
+        iList++;
+        TObject * odata = fDataSubDir->Get(key->GetName()) ;
+        dataList->AddAt(odata,iList);
+    }// while
+  }// else 
+  list[specie] = dataList;
+ } //species loop
+ Check(index,list);
+ return rv;            
+}
 //_________________________________________________________________
 Double_t * AliHMPIDQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list) 
 {
@@ -55,27 +92,31 @@ Double_t * AliHMPIDQAChecker::Check(AliQAv1::ALITASK_t index, TObjArray ** list)
   AliInfo(Form("Fix needed ....."));
   char * detOCDBDir = Form("HMPID/%s/%s", AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName()) ; 
   AliCDBEntry *QARefRec = AliQAManager::QAManager()->Get(detOCDBDir);
-  if( !QARefRec){
+  if(!QARefRec){
     AliInfo("QA reference data NOT retrieved for Reconstruction check. No HMPIDChecker  ...exiting");
     return check;
   }
 
-// checking for empy histograms
   for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
     check[specie] = 1.0;
     if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) 
       continue ; 
+    // checking for empy histograms
     if(CheckEntries(list[specie]) == 0)  {
       AliWarning("histograms are empty");
       check[specie] = 0.4;//-> Corresponds to kWARNING see AliQACheckerBase::Run
     }
   
+    //check sim
+    if(index == AliQAv1::kSIM) check[specie] = CheckSim(list[specie],(TObjArray *)QARefRec->GetObject());
+
     // checking rec points
-    if(index == AliQAv1::kREC) check[specie] = CheckRecPoints(list[specie],(TObjArray *)QARefRec->GetObject());
+    if(index == AliQAv1::kREC) check[specie] = CheckRec(list[specie],(TObjArray *)QARefRec->GetObject());
 
     //default check response. It will be changed when reasonable checks will be considered
     else check[specie] = 0.7 ; // /-> Corresponds to kINFO see AliQACheckerBase::Run 
-  }
+  } // species loop
+
   return check;
 
 }
@@ -121,8 +162,47 @@ Double_t AliHMPIDQAChecker::CheckEntries(TObjArray * list) const
   return test ; 
 }  
 //_________________________________________________________________
+Double_t AliHMPIDQAChecker::CheckSim(TObjArray *listsim, TObjArray *listref) const
+{
+  //
+  //  check on the HMPID RecPoints by using expo fit and Kolmogorov Test:
+  //
+
+   Float_t checkresponse = 0;
+
+   Float_t counter = 0 ;
+   TIter next(listsim) ;
+   TH1* histo;
+   while ( (histo = dynamic_cast<TH1 *>(next())) ) {
+     //PH The histogram should have at least 3 bins with entries
+     Int_t nbinsabove = 0;
+     for (Int_t ibin=histo->FindBin(1); ibin<=histo->FindBin(50); ibin++) { //1,50 is the fit region, see histo->Fit("expo","Q0","",1,50);
+       if (histo->GetBinContent(ibin)>0) nbinsabove++;
+     }
+
+   if( nbinsabove < 3 ) counter++;
+   else {
+    TString h = histo->GetTitle();
+    if(h.Contains("Zoom")){
+    histo->Fit("expo","LQ0","",1,50);
+    if(histo->GetFunction("expo")->GetParameter(1) !=0 ) if(TMath::Abs((-1./(histo->GetFunction("expo"))->GetParameter(1)) - 35 ) > 5) counter++;
+    }
+    if(h.Contains("size  MIP"))   if(TMath::Abs(histo->GetMean()-5) > 2) counter++;
+    if(h.Contains("size  Phots")) if(TMath::Abs(histo->GetMean()-2) > 2) counter++;
+    if(h.Contains("distribution")) if(histo->KolmogorovTest((TH1F *)listref->At(0))<0.8) counter++;
+    AliDebug(AliQAv1::GetQADebugLevel(),Form(" Kolm. test : %f ",histo->KolmogorovTest((TH1F *)listref->At(0))));  
+   }
+  }
+ Float_t response = counter/(7.+7.+42.+42.); // 7.+7.+42 +42 = N checked histograms (-> To be replaced by listsim->GetEntries())
+ if(response < 0.1) checkresponse = 0.7;      // <10% of the check histograms show a failing check -> Corresponds to kINFO see AliQACheckerBase::Run
+ else if(response < 0.5) checkresponse = 0.4; //  50%  of the check histograms show a failing check -> Corresponds to kWARNING see AliQACheckerBase::Run
+ else checkresponse = 0.001;                  // > 50% of the check histograms show a failing check -> Corresponds to kERROR see AliQACheckerBase::Run
+ return checkresponse;
+}
 
-Double_t AliHMPIDQAChecker::CheckRecPoints(TObjArray *listrec, TObjArray *listref) const
+//___________________________________________________________________________________________________
+Double_t AliHMPIDQAChecker::CheckRec(TObjArray *listrec, TObjArray *listref) const
 {
   //
   //  check on the HMPID RecPoints by using expo fit and Kolmogorov Test:
@@ -160,5 +240,4 @@ Double_t AliHMPIDQAChecker::CheckRecPoints(TObjArray *listrec, TObjArray *listre
  else checkresponse = 0.001;                  // > 50% of the check histograms show a failing check -> Corresponds to kERROR see AliQACheckerBase::Run
  return checkresponse;
 }
-//________________________________________________________________
 
index 5690a43..2947081 100644 (file)
@@ -30,10 +30,12 @@ public:
   AliHMPIDQAChecker(const AliHMPIDQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()) {;} // cpy ctor   
   virtual ~AliHMPIDQAChecker() {;} // dtor
 
+  virtual Double_t * Check(AliQAv1::ALITASK_t /*index*/) ;
   virtual Double_t * Check(AliQAv1::ALITASK_t index, TObjArray ** list) ;
   
   Double_t CheckEntries(TObjArray * list) const ;
-  Double_t CheckRecPoints(TObjArray *listrec, TObjArray *listref) const ;
+  Double_t CheckRec(TObjArray *listrec, TObjArray *listref) const ;
+  Double_t CheckSim(TObjArray *listsim, TObjArray *listref) const ;
 
 private:
   
index 20d8bb9..a0e2b59 100644 (file)
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <TObject.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TFile.h>
 #include "AliHMPIDParam.h"
 #include <AliBitPacking.h>
 #include <AliFstream.h>
 #include "AliHMPIDDigit.h"
 #include "AliDAQ.h"
 #include "AliRawDataHeaderSim.h"
+
 class AliRawReader;
 
 class AliHMPIDRawStream: public TObject {
@@ -33,9 +37,10 @@ class AliHMPIDRawStream: public TObject {
             void     InitVars(Int_t n);
             void     DelVars();
     
-   static  inline Int_t GetPad(Int_t ddl,Int_t row,Int_t dil,Int_t pad);                                                                 //get absolute pad number
-   static  Int_t GetNDDL()     { return kNDDL;}                                 //return the number of max # of DDLs
-   static  Int_t GetNErrors()  { return kSumErr;}                               //return the number of max # of Error Types
+   static  inline Int_t GetPad(Int_t ddl,Int_t row,Int_t dil,Int_t pad);               //get absolute pad number
+   static  inline Int_t GetFee(Int_t ddl,Int_t row);                                   //get the FEE number
+   static  Int_t GetNDDL()     { return kNDDL;}                                        //return the number of max # of DDLs
+   static  Int_t GetNErrors()  { return kSumErr;}                                      //return the number of max # of Error Types
 
            Int_t   GetNPads()         const { return fNPads;}                         //Get number of pads present in the stream
             Int_t*  GetPadArray()      const { return fPad;}                           //Get pad array from stream decoded
@@ -74,10 +79,12 @@ class AliHMPIDRawStream: public TObject {
 //    inline void    Raw            (UInt_t &w32,Int_t &ddl,Int_t &r,Int_t &d,Int_t &a);                                              //digit->(w32,ddl,r,d,a)
 //    inline void    Raw            (Int_t ddl,Int_t r,Int_t d,Int_t a);                                                              //raw->abs pad number
 //    inline Bool_t  Raw            (UInt_t  w32,Int_t  ddl,AliRawReader *pRR);                                                       //(w32,ddl)->digit
-    inline void    WriteRaw       (TObjArray *pDigLst                             );                                                      //write as raw stream     
-    inline void   WriteRowMarker  (AliFstream *ddl,UInt_t size);
-    inline void   WriteEoE        (AliFstream *ddl,UInt_t row,UInt_t dil,UInt_t wordCnt);  
-    inline void   WriteSegMarker  (AliFstream *ddl,UInt_t row, Int_t nwInSeg);   
+
+    inline void   WriteRaw       (TObjArray *pDigLst                             );                 //write as raw stream     
+    inline void   WriteRowMarker  (AliFstream *ddl,UInt_t size);                                    //write row marker in simulation
+    inline void   WriteEoE        (AliFstream *ddl,UInt_t row,UInt_t dil,UInt_t wordCnt);           //write Enf Of Event word in simulation
+    inline void   WriteSegMarker  (AliFstream *ddl,UInt_t row, Int_t nwInSeg);                      //write Segment Marker word in simulation
+    inline void   Write5FirmwareWords(AliFstream *ddl);                                             //write the firmware control words in simulation
     
 //    inline TClonesArray  ReMap(TClonesArray *pDigIn);
 enum EDirection {kFwd,kBwd};
@@ -129,7 +136,7 @@ enum Ebits {kbit0,kbit1 , kbit2, kbit3, kbit4, kbit5, kbit6, kbit7, kbit8,
     Int_t           *fPos;                                               // for debug purposes
     Int_t            fiPos;                                              // counter for debug
     Bool_t           fTurbo;                                             // kTRUE = Turbo decoding is called. DEFAULT: kFALSE = normal decoding is called
-    ClassDef(AliHMPIDRawStream, 2)                                       // base class for reading HMPID raw digits
+    ClassDef(AliHMPIDRawStream, 3)                                       // base class for reading HMPID raw digits
 };
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     /*
@@ -197,10 +204,8 @@ Int_t AliHMPIDRawStream::GetPad(Int_t ddl,Int_t row,Int_t dil,Int_t pad)
   // in case the charge from the channels
   // has not been read or invalid arguments
  
-  //assert(0<=ddl&&ddl<=13);  assert(1<=row&&row<=24);   assert(1<=dil&&dil<=10);     assert(0<=pad&&pad<=47);  
-  /* clm */ //corrupted data from ddl aborts the pedestal run at the assert
   if(ddl<0 || ddl >13 || row<1 || row >25 || dil<1 || dil >10 || pad<0 || pad >47 ) return -1;
-  /* clm */
   Int_t a2y[6]={3,2,4,1,5,0};     //pady for a given padress (for single DILOGIC chip)
   Int_t ch=ddl/2;
   Int_t tmp=(24-row)/8;
@@ -213,6 +218,24 @@ Int_t AliHMPIDRawStream::GetPad(Int_t ddl,Int_t row,Int_t dil,Int_t pad)
   return AliHMPIDParam::Abs(ch,pc,px,py);
 }//GetPad()
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+Int_t AliHMPIDRawStream::GetFee(Int_t ddl,Int_t row)
+{
+   // The method returns the FEE number or -1 
+   // in case of invalid argument(s)
+   if(ddl<0 || ddl >13 || row<1 || row >25  ) return -1;
+   Int_t fee=-1, kLeft=0, kRight=0;
+   if(ddl%2==0) {kLeft=1;kRight=0;}
+   if(ddl%2!=0) {kLeft=0;kRight=1;}
+   if((kLeft==1 && row<=24 && row>=21) || (kRight==1 && row<=4  && row>=1)) fee=0;    //calculation of FEE values based on Giacomos pedestal macro
+   if((kLeft==1 && row<=20 && row>=17) || (kRight==1 && row<=8  && row>=5)) fee=1;
+   if((kLeft==1 && row<=16 && row>=13) || (kRight==1 && row<=12 && row>=9)) fee=2;
+   if((kLeft==1 && row<=12 && row>=9)  || (kRight==1 && row<=16 && row>=13))fee=3;
+   if((kLeft==1 && row<=8  && row>=5)  || (kRight==1 && row<=20 && row>=17))fee=4;
+   if((kLeft==1 && row<=4  && row>=1)  || (kRight==1 && row<=24 && row>=21))fee=5;
+   return fee;
+}
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 void AliHMPIDRawStream::WriteRowMarker(AliFstream *ddl,UInt_t size)
 {
   //Writes the row marker for real data and pedestal into the ddl stream
@@ -256,6 +279,24 @@ void AliHMPIDRawStream::WriteSegMarker(AliFstream *ddl,UInt_t row, Int_t nwInSeg
       //Printf("Segment word created is: %x",w32);
 }      
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     
+void AliHMPIDRawStream::Write5FirmwareWords(AliFstream *ddl)
+{
+  //Before each DDL payload 5 words are written: 
+  // 1.) Firmware version,              for sim = 999
+  // 2.) Status and error bits from CD, for sim = 0
+  // 3.) # FEE RESET received         , for sim = 0
+  // 4.) # TTC READY                  , for sim = 0  
+  // 5.) Spare/Reserved               , for sim = 0
+  //Returns:   nothing
+  UInt_t w32=0;
+  AliBitPacking::PackWord((UInt_t)999,w32,0,31); ddl->WriteBuffer((char*)&w32,sizeof(w32));              
+  AliBitPacking::PackWord((UInt_t) 10,w32,0,31); ddl->WriteBuffer((char*)&w32,sizeof(w32));              
+  AliBitPacking::PackWord((UInt_t) 11,w32,0,31); ddl->WriteBuffer((char*)&w32,sizeof(w32));              
+  AliBitPacking::PackWord((UInt_t) 12,w32,0,31); ddl->WriteBuffer((char*)&w32,sizeof(w32));              
+  AliBitPacking::PackWord((UInt_t) 13,w32,0,31); ddl->WriteBuffer((char*)&w32,sizeof(w32));              
+  
+}
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     
 Bool_t AliHMPIDRawStream::SetZeroSup (Bool_t isSup)
 {
   //Prevision to turn OFF zero suppression
@@ -317,6 +358,11 @@ void AliHMPIDRawStream::WriteRaw(TObjArray *pDigAll)
     UInt_t w32=0;                 //32 bits data word 
     digcnt=0;
     
+    //added frimware control words
+    Write5FirmwareWords(ddlL);  cntL+=5;
+    Write5FirmwareWords(ddlR);  cntR+=5;
+   
+    
     TClonesArray *pDigCh=(TClonesArray *)pDigAll->At(iCh); //list of digits for current chamber 
    
     for(Int_t iDig=0;iDig<pDigCh->GetEntriesFast();iDig++){//digits loop
index ab8be12..b01727e 100644 (file)
@@ -2,14 +2,14 @@
 
 HMPID DA for online calibration
 
-Contact: Levente.Molnar@ba.infn.it, Giacomo.Volpe@ba.infn.it
-Link: http://richpc1.ba.infn.it/~levente/Files4Public/ValidateHmpidDA/
+Contact: Levente.Molnar@cern.ch, Giacomo.Volpe@ba.infn.it
+Link for validation file from AliEn: /alice/data/2008/LHC08c_HMPID/000047350/raw/08000047350020.10.root 
 Run Type: PEDESTAL -- but we select on the PHYSICS_EVENTS in th HMPIDda.cxx
 DA Type: LDC
-Number of events needed: 1000 events
-Input Files: Raw pedestal file, EXTERNAL config file: HmpidSigmaCut.txt on both HMPID LDCs
-Output Files: 14 txt files including pedestal values
-Trigger types used: PEDESTAL RUN (selecting on PHYSICS_EVENT)
+Number of events needed: ~ 1000 events
+Input Files: Raw pedestal file, EXTERNAL config files: HmpidSigmaCut.txt, HmpDeadChannelMap.txt on all HMPID LDCs
+Output Files: 2 x 14 txt files including pedestal and error values
+Trigger types used: PEDESTAL RUN (but selecting on PHYSICS_EVENT)
 
 */
 
@@ -39,13 +39,17 @@ extern "C" {
 #include "TObject.h"
 #include "TPluginManager.h"
 
+//AMORE
+#include <AmoreDA.h>
+
 
 int main(int argc, char **argv){ 
 
   int status;
-  const Char_t         *hmpConfigFile = "HmpDaqDaConfig.txt"; 
+  const Char_t         *hmpConfigFile        = "HmpDaqDaConfig.txt"; 
+  const Char_t         *hmpDeadChannelMapFile = "HmpDeadChannelMap.txt"; 
   const Int_t               ddlOffset = 1536;
-        TString                 hmpIn;
+        TString                 hmpIn,hmpIn2;
         TString                 feeIn;
 
   
@@ -61,34 +65,31 @@ int main(int argc, char **argv){
   }
 
   /* copy locally a file from daq detector config db */
+  
   hmpIn=Form("./%s",hmpConfigFile);
-  status=daqDA_DB_getFile(hmpConfigFile,hmpIn.Data());
-  if (status) { printf("Failed to get HMPID config file status: %d\n",status); return -1; }
+  status+=daqDA_DB_getFile(hmpConfigFile,hmpIn.Data());
+  if (status) { printf("Failed to get HMPID config file status: %d\n",status);return -1; }
+  hmpIn2=Form("./%s",hmpDeadChannelMapFile);
+  status+=daqDA_DB_getFile(hmpDeadChannelMapFile,hmpIn.Data());
+  if (status) { printf("Failed to get HMPID dead channel file status: %d\n",status);return -1; }
+  
 
   /* report progress */
   daqDA_progressReport(10);
-
-  
-  
   /* define wait event timeout - 1s max */
   monitorSetNowait();
   monitorSetNoWaitNetworkTimeout(1000);
 
   /* set local storage of ped files for Fe2C */
+
   
   /* init the pedestal calculation */
   AliHMPIDCalib *pCal=new AliHMPIDCalib();
-  /* Set the number of sigma cuts inside the file HmpidSigmaCut.txt on BOTH LDCs! */
+  /* Set the number of sigma cuts inside the file HmpidSigmaCut.txt on all LDCs! */
   /* If the file is NOT present then the default cut 3 will be used!*/
   pCal->SetSigCutFromFile(hmpIn);
-  
-  /* ONLY set this option to kTRUE if you want to create the ADC dsitributions for all 161280 pads!!!!*/  
-  /* kTRUE is not suggested for production mode b/c of the memory consumption! */
-  pCal->SetWriteHistoPads(kFALSE);               //use this option for default production useage!!!
-  //pCal->SetWriteHistoPads(kTRUE);              //only for expert debug
-  //pCal->SetWriteHistoPads(kTRUE,kTRUE,13);     //DO NOT USE THIS OPTION!
-  
+  pCal->SetDeadChannelMapFromFile(hmpIn2);  
   
   /* init event counter */
   Int_t firstEvt=0;
@@ -124,8 +125,6 @@ int main(int argc, char **argv){
         printf("End of monitoring file has been reached! \n");
         break;
         }
-      
-       
       if (status!=0) {
         printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
        return -1;
@@ -143,11 +142,6 @@ int main(int argc, char **argv){
       if (eventT==PHYSICS_EVENT || eventT==CALIBRATION_EVENT  ) {                 //updated: 18/02/2008 based on http://alice-ecs.web.cern.ch/alice-ecs/runtypes_3.16.html
         runNum=(unsigned long)event->eventRunNb;                                  //assuming that only one run is processed at a time
         ldcId=(unsigned long)event->eventLdcId;
-        if(iEvtNcal==firstEvt && pCal->GetWritePads()==kTRUE) 
-        {
-          if(pCal->GetLargePads()==kFALSE)  pCal->InitFile((Int_t)ldcId);         //The number for iEvtNcal should be the same as for the first value
-          else pCal->InitFile((Int_t)runNum);                                     //The number for iEvtNcal should be the same as for the first value
-        }
         
         iEvtNcal++;        
        AliRawReader *reader = new AliRawReaderDate((void*)event);
@@ -192,7 +186,7 @@ int main(int argc, char **argv){
 
   /* report progress */
   daqDA_progressReport(90);
-  
+  /* send pedestal and error files to DAQ FXS */
   for(Int_t nDDL=0; nDDL < AliHMPIDRawStream::kNDDL; nDDL++) {   
     feeIn=Form("thr%d.dat",ddlOffset+nDDL);         
     /* Calculate pedestal for the given ddl, if there is no ddl go t next */
@@ -206,13 +200,28 @@ int main(int argc, char **argv){
       status=daqDA_FES_storeFile(Form("HmpidErrorsDdl%02i.txt",nDDL),Form("HmpidErrorsDdl%02i.txt",nDDL));
       if (status) { printf("Failed to export file : %d\n",status); }
     }//errors
-    /* to create pedestal file as Paolo uncomment the line */
-    //if(!pCal->CalcPedestalPaolo(nDDL,Form("%sHmpidPedDdl%02i.txt",sDaOut.Data(),nDDL),iEvtNcal)) continue; 
   }//nDDL
 
-  if(pCal->GetWritePads()==kTRUE) pCal->CloseFile();
+  /* send files to AMORE DB */
+  daqDA_progressReport(95);
+  Int_t statusAmoreDA=0; 
+  amore::da::AmoreDA amoreDA(amore::da::AmoreDA::kSender);
+  for(Int_t iCh=0; iCh < AliHMPIDParam::kMaxCh; iCh++) {  
+  statusAmoreDA+=amoreDA.Send(Form("fPedMeanMap%d",iCh), pCal->GetPedMeanMap(iCh));  
+  statusAmoreDA+=amoreDA.Send(Form("fPedSigMap%d",iCh),  pCal->GetPedSigMap(iCh));  
+  }
+  for(Int_t iCh=0;iCh<=AliHMPIDParam::kMaxCh;iCh++)
+   {
+    for(Int_t iFee=0;iFee<6;iFee++)
+     {
+         statusAmoreDA+=amoreDA.Send(Form("f1DPedMean_Ch%d_FEE_%d",iCh,iFee),pCal->GetPedMean(6*iCh+iFee));
+         statusAmoreDA+=amoreDA.Send(Form("f1DPedSigma_Ch%d_FEE_%d",iCh,iFee),pCal->GetPedSigma(6*iCh+iFee));
+       }
+     }
+         
   delete pCal;  
-  if (status) return -1;
+  if(status) return -1;
+  if(statusAmoreDA) return -1;
   
   /* report progress */
   daqDA_progressReport(100);