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