[u/mrichter/AliRoot.git] / PWG4 / UserTasks / EmcalTasks / AliAnalysisTaskEMCALTriggerQA.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.                  *
 **************************************************************************/

//------------------------------------------------------------------------// 
//  Fill histograms with basic QA information for EMCAL offline trigger   //
//  Author: Nicolas Arbor (LPSC-Grenoble)                                  //
//          Gustavo Conesa Balbastre  (LPSC-Grenoble)                     //
//                                                                        //
//------------------------------------------------------------------------//


#include <TList.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TF1.h>

#include "AliLog.h"
#include "AliVCluster.h"
#include "AliVCaloCells.h"
#include "AliVEvent.h"
#include "AliESDEvent.h"
#include "AliESDVZERO.h"
#include "AliESDCaloTrigger.h"
#include "AliEMCALGeometry.h"

#include "AliAnalysisTaskEMCALTriggerQA.h"

ClassImp(AliAnalysisTaskEMCALTriggerQA)

//______________________________________________________________
AliAnalysisTaskEMCALTriggerQA::AliAnalysisTaskEMCALTriggerQA() : 
AliAnalysisTaskSE(), 
fOutputList(0),
fGeometry(0),  fGeoName("EMCAL_COMPLETEV1"),
fhNEvents(0),
fhFORAmp(0),
fhL0Amp(0),
fhL1Amp(0),
fhL1GAmp(0),
fhL1JAmp(0),
fhL0Patch(0),
fhL1GPatch(0),
fhL1JPatch(0),
fhFEESTU(0),
fhTRUSTU(0),
fhV0STU(0),
fhFullTRUSTU(0),
fhSTUChecks(0),
fNBinsSTUSignal  (2000), fMaxSTUSignal  (200000),
fNBinsTRUSignal  (2000), fMaxTRUSignal  (200000),
fNBinsV0Signal   (2000), fMaxV0Signal   (20000),
fNBinsSTUFEERatio(2000), fMaxSTUFEERatio(20000),
fNBinsSTUTRURatio(2000), fMaxSTUTRURatio(200)

{
  // Constructor
  
}		      

//______________________________________________________________________________
AliAnalysisTaskEMCALTriggerQA::AliAnalysisTaskEMCALTriggerQA(const char *name) : 
AliAnalysisTaskSE(name), 
fOutputList(0),
fGeometry(0), fGeoName("EMCAL_COMPLETEV1"),
fhNEvents(0),
fhFORAmp(0),
fhL0Amp(0),
fhL1Amp(0),
fhL1GAmp(0),
fhL1JAmp(0),
fhL0Patch(0),
fhL1GPatch(0),
fhL1JPatch(0),
fhFEESTU(0),
fhTRUSTU(0),
fhV0STU(0),
fhFullTRUSTU(0),
fhSTUChecks(0),
fNBinsSTUSignal  (2000), fMaxSTUSignal  (200000),
fNBinsTRUSignal  (2000), fMaxTRUSignal  (200000),
fNBinsV0Signal   (2000), fMaxV0Signal   (20000),
fNBinsSTUFEERatio(2000), fMaxSTUFEERatio(20000),
fNBinsSTUTRURatio(2000), fMaxSTUTRURatio(200)

{
  // Constructor
  
  DefineOutput(1, TList::Class());
  
}


//___________________________________________________________
void AliAnalysisTaskEMCALTriggerQA::UserCreateOutputObjects() 
{
  // Init histograms and geometry 
  
  fGeometry = AliEMCALGeometry::GetInstance(fGeoName);
  
  fOutputList  = new TList;
  fOutputList ->SetOwner(kTRUE);
  
  fhNEvents    = new TH1F("hNEvents","Number of selected events",1,0,1);
  fhNEvents   ->SetYTitle("N events");
  
  fhFORAmp     = new TH2F("hFORAmp", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
  fhFORAmp    ->SetXTitle("Index #eta (collumns)");
  fhFORAmp    ->SetYTitle("Index #phi (rows)");
  fhFORAmp    ->SetZTitle("Amplitude");
  
  fhL0Amp      = new TH2F("hL0Amp","FALTRO signal per Row and Column",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
  fhL0Amp     ->SetXTitle("Index #eta (collumns)");
  fhL0Amp     ->SetYTitle("Index #phi (rows)");
  fhL0Amp     ->SetZTitle("Amplitude");
  
  fhL1Amp      = new TH2F("hL1Amp","STU signal per Row and Column",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
  fhL1Amp     ->SetXTitle("Index #eta (collumns)");
  fhL1Amp     ->SetYTitle("Index #phi (rows)");
  fhL1Amp     ->SetZTitle("Amplitude");
  
  fhL1GAmp     = new TH2F("hL1GAmp","STU signal per Row and Column for L1 Gamma",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
  fhL1GAmp    ->SetXTitle("Index #eta (collumns)");
  fhL1GAmp    ->SetYTitle("Index #phi (rows)");
  fhL1GAmp    ->SetZTitle("Amplitude");
  
  fhL1JAmp     = new TH2F("hL1JAmp","STU signal per Row and Column for L1 Jet",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
  fhL1JAmp    ->SetXTitle("Index #eta (collumns)");
  fhL1JAmp    ->SetYTitle("Index #phi (rows)");
  fhL1JAmp    ->SetZTitle("Amplitude");
  
  fhL0Patch    = new TH2F("hL0Patch","FOR with associated L0 Patch",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
  fhL0Patch   ->SetXTitle("Index #eta (collumns)");
  fhL0Patch   ->SetYTitle("Index #phi (rows)");
  fhL0Patch   ->SetZTitle("counts");
  
  fhL1GPatch   = new TH2F("hL1GPatch","FOR with associated L1 Gamma Patch",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
  fhL1GPatch  ->SetXTitle("Index #eta (collumns)");
  fhL1GPatch  ->SetYTitle("Index #phi (rows)");
  fhL1GPatch  ->SetZTitle("counts");
  
  fhL1JPatch   = new TH2F("hL1JPatch","FOR with associated L1 Jet Patch",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
  fhL1JPatch  ->SetXTitle("Index #eta (collumns)");
  fhL1JPatch  ->SetYTitle("Index #phi (rows)");
  fhL1JPatch  ->SetZTitle("counts");
  
  fhFullTRUSTU = new TH2I("hFullTRUSTU","Total signal STU vs TRU",fNBinsTRUSignal,0,fMaxTRUSignal,fNBinsSTUSignal,0,fMaxSTUSignal);
  fhFullTRUSTU->SetXTitle("Total signal TRU");
  fhFullTRUSTU->SetYTitle("Total signal STU");
  fhFullTRUSTU->SetZTitle("counts");
  
  fhV0STU      = new TH2I("hV0STU","Total signal STU vs V0C+V0S",fNBinsV0Signal,0,fMaxV0Signal,fNBinsSTUSignal,0,fMaxSTUSignal);
  fhV0STU     ->SetXTitle("Signal V0C+V0A");
  fhV0STU     ->SetYTitle("Total signal STU");
  fhV0STU     ->SetZTitle("counts");
  
  fhSTUChecks  = new TH2I("hSTUChecks","Check FEE/STU link",2,0,2,15,0,15);
  fhSTUChecks ->SetXTitle("Index #eta");
  fhSTUChecks ->SetYTitle("Index #phi");
  
  fhFEESTU     = new TH2F("hFEESTU","STU / FEE vs channel", fNBinsSTUFEERatio,0,fMaxSTUFEERatio,30,0,30);
  fhFEESTU    ->SetXTitle("STU/FEE signal");
  fhFEESTU    ->SetYTitle("channel");
  fhFEESTU    ->SetZTitle("counts");
  
  fhTRUSTU     = new TH2F("hTRUSTU","STU / TRU vs channel", fNBinsSTUTRURatio,0,fMaxSTUTRURatio,30,0,30);
  fhTRUSTU    ->SetXTitle("STU/TRU signal");
  fhTRUSTU    ->SetYTitle("channel");
  fhTRUSTU    ->SetZTitle("counts");
  
  fOutputList->Add(fhNEvents);
  fOutputList->Add(fhV0STU);
  fOutputList->Add(fhFORAmp);
  fOutputList->Add(fhL0Amp);
  fOutputList->Add(fhL1Amp);
  fOutputList->Add(fhL1GAmp);
  fOutputList->Add(fhL1JAmp);
  fOutputList->Add(fhL0Patch);
  fOutputList->Add(fhL1GPatch);
  fOutputList->Add(fhL1JPatch);
  fOutputList->Add(fhFullTRUSTU);
  fOutputList->Add(fhSTUChecks);
  fOutputList->Add(fhFEESTU);
  fOutputList->Add(fhTRUSTU);
  
  PostData(1, fOutputList);  
  
}
//______________________________________________________
void AliAnalysisTaskEMCALTriggerQA::UserExec(Option_t *) 
{
  // Main loop
  
  AliVEvent* event = InputEvent();
  
  //Remove next lines when AODs ready
  AliESDEvent *esdEvent = dynamic_cast<AliESDEvent*>(event);
  
  if (!esdEvent) 
  {
    AliError("Work only with ESDs, not available, exit");
    return;
  }
  
  fhNEvents->Fill(0);
  
  //map for cells and patches
  
  Double_t emcalCell   [fgkFALTRORows][fgkFALTROCols], emcalTrigL0  [fgkFALTRORows][fgkFALTROCols], emcalTrigL1G  [fgkFALTRORows][fgkFALTROCols], emcalTrigL1J  [fgkFALTRORows][fgkFALTROCols], emcalTrigL1[fgkFALTRORows][fgkFALTROCols];
  Double_t emcalPatchL0[fgkFALTRORows][fgkFALTROCols], emcalPatchL1G[fgkFALTRORows][fgkFALTROCols], emcalPatchL1J[fgkFALTRORows][fgkFALTROCols];
  
  for (Int_t i = 0; i < fgkFALTRORows; i++) 
  {
    for (Int_t j = 0; j < fgkFALTROCols; j++) 
    {   
      emcalTrigL0[i][j]   = 0.;
      emcalTrigL1G[i][j]  = 0.;
      emcalTrigL1J[i][j]  = 0.;
      emcalTrigL1[i][j]   = 0.;
      emcalCell[i][j]     = 0.;
      emcalPatchL0[i][j]  = 0.;
      emcalPatchL1G[i][j] = 0.;
      emcalPatchL1J[i][j] = 0.;
    }
  }
  
  // ---------------------------------
  // Cells analysis
  // Fill FEE energy per channel array
  // ---------------------------------
  
  Int_t posX    = -1, posY = -1;
  Int_t nSupMod = -1, ieta = -1, iphi = -1, nModule = -1, nIphi = -1, nIeta = -1;
  Short_t absId = -1;
  Int_t nCells  =  0;
  
  AliVCaloCells& cells= *(event->GetEMCALCells());
  
  if (cells.IsEMCAL()) 
  {
    for (Int_t icell = 0; icell <  cells.GetNumberOfCells(); icell++) 
    {
      nCells ++;
      
      Double_t amp =0., time = 0.;
      
      cells.GetCell(icell, absId, amp, time);	
      
      fGeometry->GetCellIndex(absId, nSupMod, nModule, nIphi, nIeta);
      fGeometry->GetCellPhiEtaIndexInSModule(nSupMod, nModule, nIphi, nIeta, iphi, ieta); 
      
      posX = (nSupMod % 2) ? ieta + AliEMCALGeoParams::fgkEMCALCols : ieta;				
      posY = iphi + AliEMCALGeoParams::fgkEMCALRows * int(nSupMod / 2);
      
      if(int(posX/2) > fgkFALTROCols || int(posY/2) > fgkFALTRORows ) {
        printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Wrong Position (x,y) = (%d,%d)\n",posX,posY);
        continue;
      }
      
      emcalCell[int(posY/2)][int(posX/2)] += amp; 
      
    }
  }
  
  //-------------------------------------  
  // Trigger analysis, fill L0, L1 arrays
  //------------------------------------- 
  
  AliESDCaloTrigger& trg= * (esdEvent->GetCaloTrigger("EMCAL"));
  
  Int_t    nL0Patch = 0 ;
  Int_t    nL1Patch = 0 ;
  Double_t totSTU   = 0.;
  Double_t totTRU   = 0.;
  
  trg.Reset();
  while (trg.Next())
  {
    trg.GetPosition(posX,posY);
    
    
    if (posX > -1 && posY > -1) 
    {
      //L0 analysis  
      Int_t nTimes = 0;
      trg.GetNL0Times(nTimes);
      
      Float_t ampL0 = 0.;
      trg.GetAmplitude(ampL0);
      emcalTrigL0[posY][posX] += ampL0;
      totTRU += ampL0;
      
      if (nTimes) 
	    {
	      nL0Patch += nTimes;
	      emcalPatchL0[posY][posX] = 1.;
	      fhL0Patch->Fill(posX,59-posY);//59 is due to FOR reference
	    }
      
      //L1 analysis
      Int_t bit = 0;
      trg.GetTriggerBits(bit);
      
      Int_t ts = 0;
      trg.GetL1TimeSum(ts);
      emcalTrigL1 [posY][posX] += ts;
      totSTU += ts;
      
      //L1-Gamma
      if (bit >> 4 & 0x1) 
      {
        nL1Patch ++;
        emcalPatchL1G[posY][posX] = 1.;
        fhL1GPatch->Fill(posX,59-posY);
        
        emcalTrigL1G[posY][posX] += ts;
        
        //printf("Gamma STU patch %d, time sum %d, posX %d , posY %d\n",nL1Patch,ts,posX, posY);
      }
      
      //L1-Jet
      if (bit >> 5 & 0x1) 
      {
        nL1Patch ++;
        emcalPatchL1J[posY][posX] = 1.;
        fhL1JPatch->Fill(posX,59-posY);
        
        emcalTrigL1J[posY][posX] += ts;
        
        //printf("Jet STU patch %d, time sum %d, posX %d , posY %d\n",nL1Patch,ts,posX, posY);
        
      }
      
    }
  }
  
  if(totTRU > fMaxTRUSignal)printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Large totTRU %f\n",totTRU);
  if(totSTU > fMaxSTUSignal)printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Large totSTU %f\n",totSTU);
  
  if (totTRU != 0) fhFullTRUSTU->Fill(totTRU,totSTU);
  
  //V0 analysis 
  AliESDVZERO* eventV0 = esdEvent->GetVZEROData(); 
	
  Float_t v0C = 0, v0A = 0;
	
  if (eventV0) 
  {
    for (Int_t i = 0; i < 32; i++)
    {
      v0C += eventV0->GetAdcV0C(i);
      v0A += eventV0->GetAdcV0A(i);
    }
  }
  
  if (totSTU != 0) {
    fhV0STU->Fill(v0A+v0C,totSTU);
    if( v0A+v0C > fMaxV0Signal) printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Large v0A+v0C %f\n",v0A+v0C);
  }
  
  //if(nL0Patch!=0 || nL1Patch!=0) printf("total TRU %f, total STU %f, V0C+V0A %f; nL0 %d, nL1 %d \n",
  //       totTRU,totSTU,v0A+v0C,nL0Patch,nL1Patch);
  
  //Matrix with signal per channel
  for (Int_t i = 0; i < fgkFALTRORows; i++) 
  {
    for (Int_t j = 0; j < fgkFALTROCols; j++) //check x,y direction for reading FOR ((0,0) = top left);
    {
      fhFORAmp->Fill( j, fgkFALTRORows-i-1, emcalCell   [i][j]);
      fhL0Amp ->Fill( j, fgkFALTRORows-i-1, emcalTrigL0 [i][j]);
      fhL0Amp ->Fill( j, fgkFALTRORows-i-1, emcalTrigL1 [i][j]);
      fhL1GAmp->Fill( j, fgkFALTRORows-i-1, emcalTrigL1G[i][j]);
      fhL1JAmp->Fill( j, fgkFALTRORows-i-1, emcalTrigL1J[i][j]);
    }
  }
  
  //FEE-TRU-STU correlation checks
  Double_t ampFOR[30] = {0.}, ampL0[30] = {0.}, ampL1[30] = {0.};
  for (Int_t i = 0; i < fgkFALTRORows; i++) 
  {
    for (Int_t j = 0; j < fgkFALTROCols; j++) 
    {
      
      //method to get TRU number
      Int_t idFOR = -1;
      fGeometry->GetAbsFastORIndexFromPositionInEMCAL(j,i,idFOR);
      Int_t iTRU  = -1;
      Int_t iADC  = -1;
      fGeometry->GetTRUFromAbsFastORIndex(idFOR,iTRU,iADC);	
      //printf("i %d, j %d, iTRU %d, iADC %d, idFOR %d; cell %f, L0 %f, L1 %f\n", 
      //       i,j,iTRU,iADC,idFOR, emcalCell  [i][j],emcalTrigL0[i][j],emcalTrigL1[i][j]);
      if (iTRU >= 0)
      {
        ampFOR[iTRU] += emcalCell  [i][j];
        ampL0[iTRU]  += emcalTrigL0[i][j];
        ampL1[iTRU]  += emcalTrigL1[i][j];
      }
    }
  }
  
  // FEE vs STU and TRU vs STU ratios  
  for (Int_t i = 0; i < 30; i++)
  {
    
    if (ampFOR[i] != 0 && ampL1[i] != 0) { 
      fhFEESTU->Fill(ampL1[i]/ampFOR[i],i);
      if(ampL1[i]/ampFOR[i] > fMaxSTUFEERatio) printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Large STU/FEE ratio %f\n",ampL1[i]/ampFOR[i]);
    }
    
    if (ampL0[i]  != 0 && ampL1[i] != 0) {
      fhTRUSTU->Fill(ampL1[i]/ampL0[i] ,i);
      if(ampL1[i]/ampL0[i] > fMaxSTUTRURatio) printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Large STU/TRU ratio %f\n",ampL1[i]/ampL0[i]);
    }
    
  }
  
  PostData(1, fOutputList);  
  
}

//_______________________________________________________
void AliAnalysisTaskEMCALTriggerQA::Terminate(Option_t *)
{
  // Terminate analysis
  // Do some plots
  
  Int_t checkSTU[30];
  for (Int_t i = 0; i < 30; i++)
  {
    checkSTU[i] = 1 ; // Init array
    TH1F* hTRUSTUChannel = (TH1F*) fhTRUSTU->ProjectionY(Form("hTRUSTUChannel%d",i),i,i);
    //printf("AliAnalysisTaskEMCALTriggerQA::Terminate() - Channel %d TRUSTU Entries %d, Integral(10,20) %f ",
    //      i, hTRUSTUChannel->GetEntries(), hTRUSTUChannel->Integral(10,20));
    Int_t binMin = hTRUSTUChannel->FindBin(10);
    Int_t binMax = hTRUSTUChannel->FindBin(20);
    if     (hTRUSTUChannel->GetEntries() > 0 && 
            hTRUSTUChannel->Integral(binMin,binMax)/hTRUSTUChannel->GetEntries() < 0.9) 
      checkSTU[i] = 0;
    else if(hTRUSTUChannel->GetEntries() <= 0)
      checkSTU[i] = 0;
    
    //printf(" - %d\n",checkSTU[i]);
    delete hTRUSTUChannel;
  }
  
  for (Int_t i = 0; i < 30; i++)
  {
    if (i<15) fhSTUChecks->Fill(0.,i,checkSTU[i]);
    else      fhSTUChecks->Fill(1.,i,checkSTU[i]);
  }
  
}
Commit	Line	Data
bce9493b	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	//------------------------------------------------------------------------//
	17	// Fill histograms with basic QA information for EMCAL offline trigger //
	18	// Author: Nicolas Arbor (LPSC-Grenoble) //
	19	// Gustavo Conesa Balbastre (LPSC-Grenoble) //
	20	// //
	21	//------------------------------------------------------------------------//
	22
	23
	24	#include <TList.h>
	25	#include <TH1F.h>
	26	#include <TH2F.h>
	27	#include <TF1.h>
	28
	29	#include "AliLog.h"
	30	#include "AliVCluster.h"
	31	#include "AliVCaloCells.h"
	32	#include "AliVEvent.h"
	33	#include "AliESDEvent.h"
	34	#include "AliESDVZERO.h"
	35	#include "AliESDCaloTrigger.h"
	36	#include "AliEMCALGeometry.h"
	37
	38	#include "AliAnalysisTaskEMCALTriggerQA.h"
	39
	40	ClassImp(AliAnalysisTaskEMCALTriggerQA)
	41
85196c29	42	//______________________________________________________________
bce9493b	43	AliAnalysisTaskEMCALTriggerQA::AliAnalysisTaskEMCALTriggerQA() :
	44	AliAnalysisTaskSE(),
	45	fOutputList(0),
	46	fGeometry(0), fGeoName("EMCAL_COMPLETEV1"),
	47	fhNEvents(0),
e022364d	48	fhFORAmp(0),
e022364d	49	fhL0Amp(0),
aff917ac	50	fhL1Amp(0),
e022364d	51	fhL1GAmp(0),
e022364d	52	fhL1JAmp(0),
bce9493b	53	fhL0Patch(0),
	54	fhL1GPatch(0),
	55	fhL1JPatch(0),
85196c29	56	fhFEESTU(0),
85196c29	57	fhTRUSTU(0),
bce9493b	58	fhV0STU(0),
	59	fhFullTRUSTU(0),
	60	fhSTUChecks(0),
85196c29	61	fNBinsSTUSignal (2000), fMaxSTUSignal (200000),
	62	fNBinsTRUSignal (2000), fMaxTRUSignal (200000),
	63	fNBinsV0Signal (2000), fMaxV0Signal (20000),
	64	fNBinsSTUFEERatio(2000), fMaxSTUFEERatio(20000),
	65	fNBinsSTUTRURatio(2000), fMaxSTUTRURatio(200)
bce9493b	66
	67	{
	68	// Constructor
bce9493b	69
	70	}
	71
85196c29	72	//______________________________________________________________________________
bce9493b	73	AliAnalysisTaskEMCALTriggerQA::AliAnalysisTaskEMCALTriggerQA(const char *name) :
	74	AliAnalysisTaskSE(name),
	75	fOutputList(0),
	76	fGeometry(0), fGeoName("EMCAL_COMPLETEV1"),
	77	fhNEvents(0),
e022364d	78	fhFORAmp(0),
e022364d	79	fhL0Amp(0),
aff917ac	80	fhL1Amp(0),
e022364d	81	fhL1GAmp(0),
e022364d	82	fhL1JAmp(0),
bce9493b	83	fhL0Patch(0),
	84	fhL1GPatch(0),
	85	fhL1JPatch(0),
85196c29	86	fhFEESTU(0),
85196c29	87	fhTRUSTU(0),
bce9493b	88	fhV0STU(0),
	89	fhFullTRUSTU(0),
	90	fhSTUChecks(0),
85196c29	91	fNBinsSTUSignal (2000), fMaxSTUSignal (200000),
	92	fNBinsTRUSignal (2000), fMaxTRUSignal (200000),
	93	fNBinsV0Signal (2000), fMaxV0Signal (20000),
	94	fNBinsSTUFEERatio(2000), fMaxSTUFEERatio(20000),
	95	fNBinsSTUTRURatio(2000), fMaxSTUTRURatio(200)
bce9493b	96
	97	{
	98	// Constructor
bce9493b	99
	100	DefineOutput(1, TList::Class());
	101
	102	}
	103
	104
85196c29	105	//___________________________________________________________
bce9493b	106	void AliAnalysisTaskEMCALTriggerQA::UserCreateOutputObjects()
	107	{
	108	// Init histograms and geometry
	109
	110	fGeometry = AliEMCALGeometry::GetInstance(fGeoName);
	111
85196c29	112	fOutputList = new TList;
85196c29	113	fOutputList ->SetOwner(kTRUE);
bce9493b	114
85196c29	115	fhNEvents = new TH1F("hNEvents","Number of selected events",1,0,1);
85196c29	116	fhNEvents ->SetYTitle("N events");
bce9493b	117
e022364d	118	fhFORAmp = new TH2F("hFORAmp", "FEE cells deposited energy, grouped like FastOR 2x2 per Row and Column",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
	119	fhFORAmp ->SetXTitle("Index #eta (collumns)");
	120	fhFORAmp ->SetYTitle("Index #phi (rows)");
	121	fhFORAmp ->SetZTitle("Amplitude");
aff917ac	122
e022364d	123	fhL0Amp = new TH2F("hL0Amp","FALTRO signal per Row and Column",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
	124	fhL0Amp ->SetXTitle("Index #eta (collumns)");
	125	fhL0Amp ->SetYTitle("Index #phi (rows)");
	126	fhL0Amp ->SetZTitle("Amplitude");
aff917ac	127
	128	fhL1Amp = new TH2F("hL1Amp","STU signal per Row and Column",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
	129	fhL1Amp ->SetXTitle("Index #eta (collumns)");
	130	fhL1Amp ->SetYTitle("Index #phi (rows)");
	131	fhL1Amp ->SetZTitle("Amplitude");
	132
e022364d	133	fhL1GAmp = new TH2F("hL1GAmp","STU signal per Row and Column for L1 Gamma",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
	134	fhL1GAmp ->SetXTitle("Index #eta (collumns)");
	135	fhL1GAmp ->SetYTitle("Index #phi (rows)");
	136	fhL1GAmp ->SetZTitle("Amplitude");
aff917ac	137
e022364d	138	fhL1JAmp = new TH2F("hL1JAmp","STU signal per Row and Column for L1 Jet",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
	139	fhL1JAmp ->SetXTitle("Index #eta (collumns)");
	140	fhL1JAmp ->SetYTitle("Index #phi (rows)");
	141	fhL1JAmp ->SetZTitle("Amplitude");
aff917ac	142
85196c29	143	fhL0Patch = new TH2F("hL0Patch","FOR with associated L0 Patch",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
	144	fhL0Patch ->SetXTitle("Index #eta (collumns)");
	145	fhL0Patch ->SetYTitle("Index #phi (rows)");
e022364d	146	fhL0Patch ->SetZTitle("counts");
aff917ac	147
85196c29	148	fhL1GPatch = new TH2F("hL1GPatch","FOR with associated L1 Gamma Patch",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
	149	fhL1GPatch ->SetXTitle("Index #eta (collumns)");
	150	fhL1GPatch ->SetYTitle("Index #phi (rows)");
e022364d	151	fhL1GPatch ->SetZTitle("counts");
aff917ac	152
85196c29	153	fhL1JPatch = new TH2F("hL1JPatch","FOR with associated L1 Jet Patch",fgkFALTROCols,0,fgkFALTROCols,fgkFALTRORows,0,fgkFALTRORows);
	154	fhL1JPatch ->SetXTitle("Index #eta (collumns)");
	155	fhL1JPatch ->SetYTitle("Index #phi (rows)");
e022364d	156	fhL1JPatch ->SetZTitle("counts");
aff917ac	157
85196c29	158	fhFullTRUSTU = new TH2I("hFullTRUSTU","Total signal STU vs TRU",fNBinsTRUSignal,0,fMaxTRUSignal,fNBinsSTUSignal,0,fMaxSTUSignal);
bce9493b	159	fhFullTRUSTU->SetXTitle("Total signal TRU");
bce9493b	160	fhFullTRUSTU->SetYTitle("Total signal STU");
e022364d	161	fhFullTRUSTU->SetZTitle("counts");
aff917ac	162
85196c29	163	fhV0STU = new TH2I("hV0STU","Total signal STU vs V0C+V0S",fNBinsV0Signal,0,fMaxV0Signal,fNBinsSTUSignal,0,fMaxSTUSignal);
	164	fhV0STU ->SetXTitle("Signal V0C+V0A");
	165	fhV0STU ->SetYTitle("Total signal STU");
e022364d	166	fhV0STU ->SetZTitle("counts");
aff917ac	167
85196c29	168	fhSTUChecks = new TH2I("hSTUChecks","Check FEE/STU link",2,0,2,15,0,15);
	169	fhSTUChecks ->SetXTitle("Index #eta");
	170	fhSTUChecks ->SetYTitle("Index #phi");
aff917ac	171
85196c29	172	fhFEESTU = new TH2F("hFEESTU","STU / FEE vs channel", fNBinsSTUFEERatio,0,fMaxSTUFEERatio,30,0,30);
	173	fhFEESTU ->SetXTitle("STU/FEE signal");
	174	fhFEESTU ->SetYTitle("channel");
e022364d	175	fhFEESTU ->SetZTitle("counts");
aff917ac	176
85196c29	177	fhTRUSTU = new TH2F("hTRUSTU","STU / TRU vs channel", fNBinsSTUTRURatio,0,fMaxSTUTRURatio,30,0,30);
	178	fhTRUSTU ->SetXTitle("STU/TRU signal");
	179	fhTRUSTU ->SetYTitle("channel");
e022364d	180	fhTRUSTU ->SetZTitle("counts");
aff917ac	181
bce9493b	182	fOutputList->Add(fhNEvents);
bce9493b	183	fOutputList->Add(fhV0STU);
e022364d	184	fOutputList->Add(fhFORAmp);
e022364d	185	fOutputList->Add(fhL0Amp);
aff917ac	186	fOutputList->Add(fhL1Amp);
e022364d	187	fOutputList->Add(fhL1GAmp);
e022364d	188	fOutputList->Add(fhL1JAmp);
bce9493b	189	fOutputList->Add(fhL0Patch);
	190	fOutputList->Add(fhL1GPatch);
	191	fOutputList->Add(fhL1JPatch);
	192	fOutputList->Add(fhFullTRUSTU);
	193	fOutputList->Add(fhSTUChecks);
85196c29	194	fOutputList->Add(fhFEESTU);
85196c29	195	fOutputList->Add(fhTRUSTU);
bce9493b	196
	197	PostData(1, fOutputList);
	198
	199	}
85196c29	200	//______________________________________________________
bce9493b	201	void AliAnalysisTaskEMCALTriggerQA::UserExec(Option_t *)
	202	{
	203	// Main loop
bce9493b	204
	205	AliVEvent* event = InputEvent();
	206
	207	//Remove next lines when AODs ready
	208	AliESDEvent esdEvent = dynamic_cast<AliESDEvent>(event);
	209
	210	if (!esdEvent)
	211	{
	212	AliError("Work only with ESDs, not available, exit");
	213	return;
	214	}
	215
	216	fhNEvents->Fill(0);
	217
bce9493b	218	//map for cells and patches
bce9493b	219
e022364d	220	Double_t emcalCell [fgkFALTRORows][fgkFALTROCols], emcalTrigL0 [fgkFALTRORows][fgkFALTROCols], emcalTrigL1G [fgkFALTRORows][fgkFALTROCols], emcalTrigL1J [fgkFALTRORows][fgkFALTROCols], emcalTrigL1[fgkFALTRORows][fgkFALTROCols];
bce9493b	221	Double_t emcalPatchL0[fgkFALTRORows][fgkFALTROCols], emcalPatchL1G[fgkFALTRORows][fgkFALTROCols], emcalPatchL1J[fgkFALTRORows][fgkFALTROCols];
	222
	223	for (Int_t i = 0; i < fgkFALTRORows; i++)
	224	{
	225	for (Int_t j = 0; j < fgkFALTROCols; j++)
	226	{
85196c29	227	emcalTrigL0[i][j] = 0.;
e022364d	228	emcalTrigL1G[i][j] = 0.;
e022364d	229	emcalTrigL1J[i][j] = 0.;
85196c29	230	emcalTrigL1[i][j] = 0.;
	231	emcalCell[i][j] = 0.;
	232	emcalPatchL0[i][j] = 0.;
bce9493b	233	emcalPatchL1G[i][j] = 0.;
	234	emcalPatchL1J[i][j] = 0.;
	235	}
	236	}
	237
	238	// ---------------------------------
	239	// Cells analysis
	240	// Fill FEE energy per channel array
	241	// ---------------------------------
	242
	243	Int_t posX = -1, posY = -1;
	244	Int_t nSupMod = -1, ieta = -1, iphi = -1, nModule = -1, nIphi = -1, nIeta = -1;
	245	Short_t absId = -1;
	246	Int_t nCells = 0;
	247
	248	AliVCaloCells& cells= *(event->GetEMCALCells());
	249
	250	if (cells.IsEMCAL())
	251	{
	252	for (Int_t icell = 0; icell < cells.GetNumberOfCells(); icell++)
	253	{
	254	nCells ++;
	255
	256	Double_t amp =0., time = 0.;
	257
	258	cells.GetCell(icell, absId, amp, time);
	259
	260	fGeometry->GetCellIndex(absId, nSupMod, nModule, nIphi, nIeta);
	261	fGeometry->GetCellPhiEtaIndexInSModule(nSupMod, nModule, nIphi, nIeta, iphi, ieta);
	262
	263	posX = (nSupMod % 2) ? ieta + AliEMCALGeoParams::fgkEMCALCols : ieta;
	264	posY = iphi + AliEMCALGeoParams::fgkEMCALRows * int(nSupMod / 2);
bce9493b	265
85196c29	266	if(int(posX/2) > fgkFALTROCols \|\| int(posY/2) > fgkFALTRORows ) {
	267	printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Wrong Position (x,y) = (%d,%d)\n",posX,posY);
	268	continue;
	269	}
	270
	271	emcalCell[int(posY/2)][int(posX/2)] += amp;
	272
bce9493b	273	}
	274	}
	275
85196c29	276	//-------------------------------------
	277	// Trigger analysis, fill L0, L1 arrays
	278	//-------------------------------------
bce9493b	279
	280	AliESDCaloTrigger& trg= * (esdEvent->GetCaloTrigger("EMCAL"));
	281
	282	Int_t nL0Patch = 0 ;
	283	Int_t nL1Patch = 0 ;
	284	Double_t totSTU = 0.;
	285	Double_t totTRU = 0.;
	286
	287	trg.Reset();
	288	while (trg.Next())
	289	{
	290	trg.GetPosition(posX,posY);
	291
	292
	293	if (posX > -1 && posY > -1)
	294	{
	295	//L0 analysis
	296	Int_t nTimes = 0;
	297	trg.GetNL0Times(nTimes);
85196c29	298
aff917ac	299	Float_t ampL0 = 0.;
	300	trg.GetAmplitude(ampL0);
	301	emcalTrigL0[posY][posX] += ampL0;
	302	totTRU += ampL0;
	303
bce9493b	304	if (nTimes)
	305	{
	306	nL0Patch += nTimes;
bce9493b	307	emcalPatchL0[posY][posX] = 1.;
aff917ac	308	fhL0Patch->Fill(posX,59-posY);//59 is due to FOR reference
bce9493b	309	}
	310
	311	//L1 analysis
	312	Int_t bit = 0;
	313	trg.GetTriggerBits(bit);
	314
aff917ac	315	Int_t ts = 0;
	316	trg.GetL1TimeSum(ts);
	317	emcalTrigL1 [posY][posX] += ts;
	318	totSTU += ts;
	319
bce9493b	320	//L1-Gamma
	321	if (bit >> 4 & 0x1)
	322	{
	323	nL1Patch ++;
	324	emcalPatchL1G[posY][posX] = 1.;
aff917ac	325	fhL1GPatch->Fill(posX,59-posY);
	326
	327	emcalTrigL1G[posY][posX] += ts;
bce9493b	328
85196c29	329	//printf("Gamma STU patch %d, time sum %d, posX %d , posY %d\n",nL1Patch,ts,posX, posY);
bce9493b	330	}
	331
	332	//L1-Jet
	333	if (bit >> 5 & 0x1)
	334	{
	335	nL1Patch ++;
	336	emcalPatchL1J[posY][posX] = 1.;
aff917ac	337	fhL1JPatch->Fill(posX,59-posY);
	338
	339	emcalTrigL1J[posY][posX] += ts;
bce9493b	340
85196c29	341	//printf("Jet STU patch %d, time sum %d, posX %d , posY %d\n",nL1Patch,ts,posX, posY);
aff917ac	342
bce9493b	343	}
	344
	345	}
	346	}
	347
85196c29	348	if(totTRU > fMaxTRUSignal)printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Large totTRU %f\n",totTRU);
85196c29	349	if(totSTU > fMaxSTUSignal)printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Large totSTU %f\n",totSTU);
bce9493b	350
	351	if (totTRU != 0) fhFullTRUSTU->Fill(totTRU,totSTU);
	352
	353	//V0 analysis
	354	AliESDVZERO* eventV0 = esdEvent->GetVZEROData();
	355
	356	Float_t v0C = 0, v0A = 0;
	357
	358	if (eventV0)
	359	{
	360	for (Int_t i = 0; i < 32; i++)
	361	{
	362	v0C += eventV0->GetAdcV0C(i);
	363	v0A += eventV0->GetAdcV0A(i);
	364	}
	365	}
	366
	367	if (totSTU != 0) {
	368	fhV0STU->Fill(v0A+v0C,totSTU);
85196c29	369	if( v0A+v0C > fMaxV0Signal) printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Large v0A+v0C %f\n",v0A+v0C);
bce9493b	370	}
bce9493b	371
85196c29	372	//if(nL0Patch!=0 \|\| nL1Patch!=0) printf("total TRU %f, total STU %f, V0C+V0A %f; nL0 %d, nL1 %d \n",
	373	// totTRU,totSTU,v0A+v0C,nL0Patch,nL1Patch);
	374
bce9493b	375	//Matrix with signal per channel
e022364d	376	for (Int_t i = 0; i < fgkFALTRORows; i++)
bce9493b	377	{
e022364d	378	for (Int_t j = 0; j < fgkFALTROCols; j++) //check x,y direction for reading FOR ((0,0) = top left);
bce9493b	379	{
e022364d	380	fhFORAmp->Fill( j, fgkFALTRORows-i-1, emcalCell [i][j]);
e022364d	381	fhL0Amp ->Fill( j, fgkFALTRORows-i-1, emcalTrigL0 [i][j]);
aff917ac	382	fhL0Amp ->Fill( j, fgkFALTRORows-i-1, emcalTrigL1 [i][j]);
e022364d	383	fhL1GAmp->Fill( j, fgkFALTRORows-i-1, emcalTrigL1G[i][j]);
e022364d	384	fhL1JAmp->Fill( j, fgkFALTRORows-i-1, emcalTrigL1J[i][j]);
bce9493b	385	}
	386	}
	387
aff917ac	388	//FEE-TRU-STU correlation checks
bce9493b	389	Double_t ampFOR[30] = {0.}, ampL0[30] = {0.}, ampL1[30] = {0.};
e022364d	390	for (Int_t i = 0; i < fgkFALTRORows; i++)
bce9493b	391	{
e022364d	392	for (Int_t j = 0; j < fgkFALTROCols; j++)
bce9493b	393	{
	394
	395	//method to get TRU number
85196c29	396	Int_t idFOR = -1;
	397	fGeometry->GetAbsFastORIndexFromPositionInEMCAL(j,i,idFOR);
	398	Int_t iTRU = -1;
	399	Int_t iADC = -1;
	400	fGeometry->GetTRUFromAbsFastORIndex(idFOR,iTRU,iADC);
	401	//printf("i %d, j %d, iTRU %d, iADC %d, idFOR %d; cell %f, L0 %f, L1 %f\n",
	402	// i,j,iTRU,iADC,idFOR, emcalCell [i][j],emcalTrigL0[i][j],emcalTrigL1[i][j]);
bce9493b	403	if (iTRU >= 0)
	404	{
	405	ampFOR[iTRU] += emcalCell [i][j];
	406	ampL0[iTRU] += emcalTrigL0[i][j];
	407	ampL1[iTRU] += emcalTrigL1[i][j];
	408	}
	409	}
	410	}
	411
85196c29	412	// FEE vs STU and TRU vs STU ratios
bce9493b	413	for (Int_t i = 0; i < 30; i++)
bce9493b	414	{
85196c29	415
	416	if (ampFOR[i] != 0 && ampL1[i] != 0) {
	417	fhFEESTU->Fill(ampL1[i]/ampFOR[i],i);
	418	if(ampL1[i]/ampFOR[i] > fMaxSTUFEERatio) printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Large STU/FEE ratio %f\n",ampL1[i]/ampFOR[i]);
	419	}
	420
	421	if (ampL0[i] != 0 && ampL1[i] != 0) {
	422	fhTRUSTU->Fill(ampL1[i]/ampL0[i] ,i);
	423	if(ampL1[i]/ampL0[i] > fMaxSTUTRURatio) printf("AliAnalysisTaskEMCALTriggerQA::UserExec() - Large STU/TRU ratio %f\n",ampL1[i]/ampL0[i]);
	424	}
	425
bce9493b	426	}
bce9493b	427
bce9493b	428	PostData(1, fOutputList);
	429
	430	}
	431
85196c29	432	//_______________________________________________________
	433	void AliAnalysisTaskEMCALTriggerQA::Terminate(Option_t *)
	434	{
	435	// Terminate analysis
	436	// Do some plots
	437
	438	Int_t checkSTU[30];
	439	for (Int_t i = 0; i < 30; i++)
	440	{
	441	checkSTU[i] = 1 ; // Init array
	442	TH1F* hTRUSTUChannel = (TH1F*) fhTRUSTU->ProjectionY(Form("hTRUSTUChannel%d",i),i,i);
	443	//printf("AliAnalysisTaskEMCALTriggerQA::Terminate() - Channel %d TRUSTU Entries %d, Integral(10,20) %f ",
	444	// i, hTRUSTUChannel->GetEntries(), hTRUSTUChannel->Integral(10,20));
aff917ac	445	Int_t binMin = hTRUSTUChannel->FindBin(10);
aff917ac	446	Int_t binMax = hTRUSTUChannel->FindBin(20);
85196c29	447	if (hTRUSTUChannel->GetEntries() > 0 &&
aff917ac	448	hTRUSTUChannel->Integral(binMin,binMax)/hTRUSTUChannel->GetEntries() < 0.9)
85196c29	449	checkSTU[i] = 0;
	450	else if(hTRUSTUChannel->GetEntries() <= 0)
	451	checkSTU[i] = 0;
	452
	453	//printf(" - %d\n",checkSTU[i]);
	454	delete hTRUSTUChannel;
	455	}
	456
	457	for (Int_t i = 0; i < 30; i++)
	458	{
	459	if (i<15) fhSTUChecks->Fill(0.,i,checkSTU[i]);
	460	else fhSTUChecks->Fill(1.,i,checkSTU[i]);
	461	}
	462
	463	}