/**************************************************************************
 * 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.                  *
 **************************************************************************/

//_________________________________________________________________________
// Base class for CaloTrackCorr analysis algorithms
//-- Author: Gustavo Conesa (LNF-INFN, LPSC-Grenoble) 
//
//
//_________________________________________________________________________


// --- ROOT system ---
#include <TClonesArray.h>
//#include <Riostream.h>

//---- AliRoot system ----
#include "AliAnaCaloTrackCorrBaseClass.h"
#include "AliCaloTrackReader.h"
#include "AliCalorimeterUtils.h"
#include "AliCaloPID.h"
#include "AliFiducialCut.h"
#include "AliIsolationCut.h"
#include "AliMCAnalysisUtils.h"
#include "AliNeutralMesonSelection.h"
#include "AliVCaloCells.h" 
#include "AliAODEvent.h"
#include "AliAODHandler.h"
#include "AliAODPWG4Particle.h"

ClassImp(AliAnaCaloTrackCorrBaseClass)


//__________________________________________________________
AliAnaCaloTrackCorrBaseClass::AliAnaCaloTrackCorrBaseClass() : 
TObject(), 
fDataMC(0),                   fDebug(0),
fCalorimeter(-1),             fCalorimeterString(""),
fCheckFidCut(0),              fCheckRealCaloAcc(0),
fCheckCaloPID(0),             fRecalculateCaloPID(0), 
fMinPt(0),                    fMaxPt(0),
fPairTimeCut(200),            fTRDSMCovered(-1),
fNZvertBin(0),                fNrpBin(0),
fNCentrBin(0),                fNmaxMixEv(0),
fDoOwnMix(0),                 fUseTrackMultBins(0),
fFillPileUpHistograms(0),     fFillHighMultHistograms(0),
fMakePlots(kFALSE),
fInputAODBranch(0x0),         fInputAODName(""),
fOutputAODBranch(0x0),        fNewAOD(kFALSE),
fOutputAODName(""),           fOutputAODClassName(""),
fAODObjArrayName(""),         fAddToHistogramsName(""),
fCaloPID(0x0),                fCaloUtils(0x0),
fFidCut(0x0),                 fHisto(0x0),
fIC(0x0),                     fMCUtils(0x0),                
fNMS(0x0),                    fReader(0x0)
{
  //Default Ctor
  
  //Initialize parameters
  InitParameters();
}

//___________________________________________________________
AliAnaCaloTrackCorrBaseClass::~AliAnaCaloTrackCorrBaseClass() 
{
  // Remove all pointers except analysis output pointers.
  
  //delete fCaloUtils ; //Already deleted in maker
  //delete fReader ;    //Already deleted in maker
	
  delete fCaloPID ; 
  delete fFidCut  ;  
  delete fIC      ;      
  delete fMCUtils ; 
  delete fNMS     ;     
  delete fHisto   ;    
}

//______________________________________________________________________
void AliAnaCaloTrackCorrBaseClass::AddAODParticle(AliAODPWG4Particle pc)
{
  //Put AOD calo cluster in the AODParticleCorrelation array
  
  if(!fOutputAODBranch)
  {
    AliFatal("No AOD branch available!!!\n");
    return; // coverity
  }
  
  Int_t i = fOutputAODBranch->GetEntriesFast();
  //new((*fOutputAODBranch)[i])  AliAODPWG4Particle(pc);
  if     (strcmp(fOutputAODBranch->GetClass()->GetName(),"AliAODPWG4Particle")==0)
  {
    new((*fOutputAODBranch)[i])  AliAODPWG4Particle(pc);
  }
  else if(strcmp(fOutputAODBranch->GetClass()->GetName(),"AliAODPWG4ParticleCorrelation")==0)
  {
    new((*fOutputAODBranch)[i])  AliAODPWG4ParticleCorrelation(pc);
  }
  else
  {
    AliFatal(Form("Cannot add an object of type < %s >, to the AOD TClonesArray \n", fOutputAODBranch->GetClass()->GetName()));
  }
  
}

//__________________________________________________________________________________________
Int_t AliAnaCaloTrackCorrBaseClass::CheckMixedEventVertex(Int_t caloLabel, Int_t trackLabel)
{
  // Check vertex in mixed events
  
  if (!GetMixedEvent()) return 1; // Not mixed event continue normal processing
  
  Int_t evt = -1;
  
  if     (caloLabel  >= 0 )
  {
    evt = GetMixedEvent()->EventIndexForCaloCluster(caloLabel) ;
  }
  else if(trackLabel >= 0 )
  {
    evt = GetMixedEvent()->EventIndex(trackLabel) ;
  }
  else  
    return 0; // go to next entry in the particle list
  
  if(evt == -1) 
    return 0 ; // to content coverity
  
  if (TMath::Abs(GetVertex(evt)[2]) > GetZvertexCut())  return -1; // Vertex out of range process next event
  
  return 1 ; // continue processing normally
  
}

//________________________________________________________________
void AliAnaCaloTrackCorrBaseClass::ConnectInputOutputAODBranches() 
{
  //Recover ouput and input AOD pointers for each event in the maker
	
  //Delta AODs
  AliDebug(3,Form("AliAnaCaloTrackCorrBaseClass::ConnectInputOutputAODBranches() - Connect Input with name: <%s>; Connect output with name <%s>\n",fInputAODName.Data(),fOutputAODName.Data()));
  
  //Get the AOD handler, if output AOD is created use it, if not get the branches from the input which should be deltaAODs
  AliAODHandler* aodHandler = 0x0;
  Bool_t outAOD = kFALSE;
  if((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()) outAOD = kTRUE;
  if(outAOD) aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()); 
  else 	     aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
  
  if(!GetReader()->WriteDeltaAODToFile())
  {
    fOutputAODBranch =  (TClonesArray *) (fReader->GetAODBranchList())->FindObject(fOutputAODName);
    fInputAODBranch  =  (TClonesArray *) (fReader->GetAODBranchList())->FindObject(fInputAODName);	
  }
  else if (aodHandler->GetExtensions())
  {
    AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject(GetReader()->GetDeltaAODFileName()); 
    if(ext)
    {
      AliAODEvent *aodEvent = ext->GetAOD(); 
      if(fNewAOD)fOutputAODBranch = (TClonesArray*) aodEvent->FindListObject(fOutputAODName);
      fInputAODBranch = (TClonesArray*) aodEvent->FindListObject(fInputAODName); 	  
      if(!fOutputAODBranch && fNewAOD) fOutputAODBranch =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fOutputAODName);
      if(!fInputAODBranch)  fInputAODBranch  =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fInputAODName);
    }
    else
    { // If no Delta AODs, kept in standard branch, to revise.
      if(fNewAOD && fReader->GetOutputEvent())
      {
        fOutputAODBranch =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fOutputAODName);
        fInputAODBranch  =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fInputAODName);	
      }
      else
      {
        fInputAODBranch  =  (TClonesArray *) fReader->GetInputEvent()->FindListObject(fInputAODName);	
        if(!fInputAODBranch && fReader->GetOutputEvent() ) 
          fInputAODBranch  =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fInputAODName);//Try the output event.
      }
    }
  }
  else
  { // If no Delta AODs, kept in standard branch
    if(fNewAOD && fReader->GetOutputEvent())
    {
      fOutputAODBranch =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fOutputAODName);
      fInputAODBranch  =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fInputAODName);	
    }
    else
    {
      fInputAODBranch  =  (TClonesArray *) fReader->GetInputEvent()->FindListObject(fInputAODName);
      if(!fInputAODBranch && fReader->GetOutputEvent())  
        fInputAODBranch  =  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(fInputAODName);//Try the output event.
    }
  }
  
//  if(GetDebug() > 1)
//  {
//    if(fNewAOD && !fOutputAODBranch) 
//      AliInfo(Form("Output Branch <%s>, not found!\n",fOutputAODName.Data()));
//    if(!fNewAOD && !fInputAODBranch) 
//      AliInfo(Form("Input Branch  <%s>, not found!\n",fInputAODName.Data()));
//  }
}

//_____________________________________________________________________________________
AliVCluster * AliAnaCaloTrackCorrBaseClass::FindCluster(TObjArray* clusters, Int_t id,
                                                        Int_t & iclus, Int_t first)
{
  // Given the cluster ID stored in AliAODPWG4Particle, get the originator cluster and its index in the array
  
  if(!clusters) return 0x0;
  
  for(iclus = first; iclus < clusters->GetEntriesFast(); iclus++)
  {
    AliVCluster *cluster= dynamic_cast<AliVCluster*> (clusters->At(iclus));
    if(cluster)
    {
      if(cluster->GetID()==id)
      {
        return cluster;
      }
    }      
  }// calorimeter clusters loop
  
  return 0x0;
  
}

//______________________________________________________________________________________
TClonesArray * AliAnaCaloTrackCorrBaseClass::GetAODBranch(const TString & aodName) const
{
	//Recover ouput and input AOD pointers for each event in the maker
	
	//Delta AODs
  
	AliDebug(3,Form("AliAnaCaloTrackCorrBaseClass::GetAODBranch() - Get Input Branch with name: <%s>; \n",aodName.Data()));
	
  //Get the AOD handler, if output AOD is created use it, if not get the branches from the input which should be deltaAODs
  AliAODHandler* aodHandler = 0x0;
  Bool_t outAOD = kFALSE;
  if((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()) outAOD = kTRUE;
  if(outAOD) aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()); 
  else 	     aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
  
  if(!GetReader()->WriteDeltaAODToFile())
  {
    return  (TClonesArray *) (fReader->GetAODBranchList())->FindObject(aodName);
  }
  else if (aodHandler->GetExtensions())
  { 
    AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject(GetReader()->GetDeltaAODFileName()); 
    if(ext){
      AliAODEvent *aodEvent = ext->GetAOD(); 
      TClonesArray * aodbranch =  (TClonesArray*) aodEvent->FindListObject(aodName);
      if(aodbranch) return aodbranch;
      else {
        if(outAOD) return  (TClonesArray *) fReader->GetOutputEvent()->FindListObject(aodName);
        else       return  (TClonesArray *) fReader->GetInputEvent() ->FindListObject(aodName);
      }
    }
    else{//If no Delta AODs, kept in standard branch, to revise. 
      if(outAOD) return (TClonesArray *) fReader->GetOutputEvent()->FindListObject(aodName);
      else       return (TClonesArray *) fReader->GetInputEvent() ->FindListObject(aodName);
    }
  }
  else{ //If no Delta AODs, kept in standard branch, to revise. 
    if(outAOD) return (TClonesArray *)  fReader->GetOutputEvent()->FindListObject(aodName);
    else       return  (TClonesArray *) fReader->GetInputEvent() ->FindListObject(aodName);
  }
  
}

//_____________________________________________________________
TObjArray *  AliAnaCaloTrackCorrBaseClass::GetCTSTracks() const 
{
  //Get list of referenced tracks from reader
  
  return fReader->GetCTSTracks(); 
  
}

//________________________________________________________________
TObjArray *  AliAnaCaloTrackCorrBaseClass::GetPHOSClusters() const 
{
  //Get list of PHOS reference caloclusters from reader
  
  return fReader->GetPHOSClusters(); 
  
}

//_________________________________________________________________
TObjArray *  AliAnaCaloTrackCorrBaseClass::GetEMCALClusters() const 
{
  //Get list of emcal referenced caloclusters from reader
  
  return fReader->GetEMCALClusters(); 
  
}

//______________________________________________________________________
TClonesArray *  AliAnaCaloTrackCorrBaseClass::GetAODCaloClusters() const 
{
  //Get list of all caloclusters in AOD output file 
  
  return fReader->GetOutputEvent()->GetCaloClusters(); 
  
}

//________________________________________________________________
TClonesArray *  AliAnaCaloTrackCorrBaseClass::GetAODTracks() const 
{
  //Get list of all tracks in AOD output file 
  
  return fReader->GetOutputEvent()->GetTracks(); 
  
}

//____________________________________________________________
TString  AliAnaCaloTrackCorrBaseClass::GetBaseParametersList()  
{
  //Put data member values in string to keep in output container
  
  TString parList ; //this will be list of parameters used for this analysis.
  const Int_t buffersize = 255;
  char onePar[buffersize] ;
  snprintf(onePar,buffersize,"--- AliAnaCaloTrackCorrBaseClass ---\n") ;
  parList+=onePar ;	
  snprintf(onePar,buffersize,"Minimal P_t: %2.2f ; Max\n", fMinPt) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"Minimal P_t: %2.2f ; Max\n", fMaxPt) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"|t_{1}-t_{2}| < %2.2f ; Max\n", fPairTimeCut) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"fDataMC =%d (Check MC information, on/off) \n",fDataMC) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"fCheckFidCut=%d (Check Fiducial cut selection on/off) \n",fCheckFidCut) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"fCheckRealCaloAcc=%d (Check Real Calo Acceptance on/off) \n",fCheckRealCaloAcc) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"fCheckCaloPID =%d (Use Bayesian PID in calorimetes, on/off) \n",fCheckCaloPID) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"fRecalculateCaloPID  =%d (Calculate PID from shower/tof/tracking parameters, on/off) \n",fRecalculateCaloPID) ;
  parList+=onePar ;
  snprintf(onePar,buffersize,"fInputAODName  =%s Input AOD name \n",fInputAODName.Data()) ;
  parList+=onePar ;	
  if(fNewAOD)
  {
    snprintf(onePar,buffersize,"fOutputAODName  =%s Output AOD name \n",fOutputAODName.Data()) ;
    parList+=onePar ;	
    snprintf(onePar,buffersize,"fOutputAODClassName  =%s Output AOD class name \n",fOutputAODClassName.Data()) ;
    parList+=onePar ;	
  }
  snprintf(onePar,buffersize,"fAODObjArrayName  =%s Reference arrays in AOD name \n",fAODObjArrayName.Data()) ;
  parList+=onePar ;	
  snprintf(onePar,buffersize,"fAddToHistogramsName  =%s String added to beginning of histograms name \n",fAddToHistogramsName.Data()) ;
  parList+=onePar ;	
	
  return parList; 
  
}

//_____________________________________________________________________
TClonesArray * AliAnaCaloTrackCorrBaseClass::GetCreateOutputAODBranch() 
{
  //Create AOD branch filled in the analysis
  
  AliInfo(Form("Create AOD branch of %s objects and with name < %s >\n",
          fOutputAODClassName.Data(),fOutputAODName.Data())) ;
  
  TClonesArray * aodBranch = new TClonesArray(fOutputAODClassName, 0);
  aodBranch->SetName(fOutputAODName);
  return aodBranch ;
  
}

//________________________________________________________
Int_t AliAnaCaloTrackCorrBaseClass::GetEventNumber() const 
{
  //Get current event number
  
  return fReader->GetEventNumber() ; 
  
}


//__________________________________________________________
AliStack *  AliAnaCaloTrackCorrBaseClass::GetMCStack() const 
{
  //Get stack pointer from reader
  
  return fReader->GetStack(); 
  
}
//____________________________________________________________
AliHeader *  AliAnaCaloTrackCorrBaseClass::GetMCHeader() const
{
  //Get header pointer from reader
  
  return fReader->GetHeader(); 
  
}

//____________________________________________________________________________
AliGenEventHeader *  AliAnaCaloTrackCorrBaseClass::GetMCGenEventHeader() const
{
  //Get GenEventHeader pointer from reader
  
  return fReader->GetGenEventHeader(); 
  
}


//_________________________________________________________________
Int_t AliAnaCaloTrackCorrBaseClass::GetTrackMultiplicityBin() const
{
  // Track multiplicity bins
  
  //curCentrBin = (GetTrackMultiplicity()-1)/5;
  //if(curCentrBin > GetNCentrBin()-1) curCentrBin=GetNCentrBin()-1;
  Int_t trackMult = GetReader()->GetTrackMultiplicity();
  
  for(Int_t ibin = 0; ibin < GetNTrackMultBin()-1; ibin++)
  {
    if(trackMult >= fTrackMultBins[ibin] && trackMult < fTrackMultBins[ibin+1]) return ibin;
  }
  
  AliWarning(Form("Bin not found for track multiplicity %d",trackMult));
  
  return -1;
}

//________________________________________________________________
Int_t AliAnaCaloTrackCorrBaseClass::GetEventCentralityBin() const
{
  // Define the centrality bin for mixing
  // In pp collisions analysis hardcoded track multiplicities
  
  Int_t curCentrBin = 0;
  
  if(fUseTrackMultBins) // pp collisions
  {
    return GetTrackMultiplicityBin();
  }
  else // Set centrality based on centrality task, PbPb collisions
  {
    Float_t minCent = GetReader()->GetCentralityBin(0);
    Float_t maxCent = GetReader()->GetCentralityBin(1);
    
    if((minCent< 0 && maxCent< 0) || minCent>=maxCent)
    {
      curCentrBin = GetEventCentrality() * GetNCentrBin() / GetReader()->GetCentralityOpt();
      if(curCentrBin==GetNCentrBin())
      {
        curCentrBin = GetNCentrBin()-1;
        AliDebug(1,Form("Centrality = %d, put it in last bin \n",GetEventCentrality()));
      }
    }
    else
    {
      curCentrBin = (Int_t)((GetEventCentrality()-minCent) * GetNCentrBin() / (maxCent-minCent));
      if(curCentrBin==GetNCentrBin()) curCentrBin = GetNCentrBin()-1;
    }
    
    AliDebug(1,Form("Current CentrBin %d, centrality %d, n bins %d, max bin from centrality %d",
                    curCentrBin, GetEventCentrality(), GetNCentrBin(), GetReader()->GetCentralityOpt()));
  }
  
  return curCentrBin;
  
}

//_______________________________________________________
Int_t AliAnaCaloTrackCorrBaseClass::GetEventRPBin() const
{
  //Reaction plane bin
  
  Int_t curRPBin  = 0 ;
  
  if(GetNRPBin() > 1 && GetEventPlane())
  {
    Float_t epAngle = GetEventPlaneAngle();//->GetEventplane(GetEventPlaneMethod(),fReader->GetInputEvent());
    
    if(epAngle < 0 || epAngle >TMath::Pi())
    { 
      AliWarning(Form("Wrong event plane angle : %f \n",epAngle));
      return -1;
    }
    
    curRPBin = TMath::Nint(epAngle*(GetNRPBin()-1)/TMath::Pi());
    if(curRPBin >= GetNRPBin()) printf("RP Bin %d out of range %d",curRPBin,GetNRPBin());
    
    AliDebug(1,Form("Current RP bin %d, bin float %f, angle %f, n bins %d",
                    curRPBin,epAngle*(GetNRPBin()-1)/TMath::Pi(),epAngle,GetNRPBin()));
  }  
  
  return curRPBin ;
  
}

//_______________________________________________________
Int_t AliAnaCaloTrackCorrBaseClass::GetEventVzBin() const
{
  // Return Vz bin, divide vertex in GetNZvertBin() bins, 
  // depending on the vertex cut
  
  Double_t v[3] = {0,0,0}; //vertex 
  GetReader()->GetVertex(v);
  
  Int_t curZvertBin = (Int_t)(0.5*GetNZvertBin()*(v[2]+GetZvertexCut())/GetZvertexCut());
  
  AliDebug(1,Form("AliAnaCaloTrackCorrBaseClass::GetEventVzBin() - %d, vz %2.2f, n bins %d",
                  curZvertBin, v[2], GetNZvertBin()));
  
  return curZvertBin;
}

//________________________________________________________________________________________
Int_t AliAnaCaloTrackCorrBaseClass::GetEventMixBin(Int_t iCen, Int_t iVz, Int_t iRP) const
{
  // Event mixing bin, combination of vz, centrality and reaction plane bins
  
  if(iCen<0 || iVz < 0 || iRP < 0)
    return -1;
  else
    return iCen*GetNZvertBin()*GetNRPBin()+iVz*GetNRPBin()+iRP;
}

//________________________________________________________
Int_t AliAnaCaloTrackCorrBaseClass::GetEventMixBin() const
{
  // Event mixing bin, combination of vz, centrality and reaction plane bins
  
  //Get vertex z bin
  Int_t iVz =  GetEventVzBin();
  
  // centrality (PbPb) or tracks multiplicity (pp) bin
  Int_t iCen = GetEventCentralityBin();
  
  // reaction plane bin (PbPb)
  Int_t iRP = GetEventRPBin();  
  
  Int_t eventBin = GetEventMixBin(iCen, iVz, iRP);
  
  AliDebug(1,Form("Bins : cent %d, vz %d, RP %d, event %d/%d",
                  iCen,iVz, iRP, eventBin, GetNZvertBin()*GetNRPBin()*GetNCentrBin()));
  
  return eventBin;
  
}

//____________________________________________
void AliAnaCaloTrackCorrBaseClass::InitDebug()
{
  // Init once the debugging level, if requested
  
  // Activate debug level in analysis

  if( fDebug >= 0 )
    (AliAnalysisManager::GetAnalysisManager())->AddClassDebug(this->ClassName(),fDebug);
  
  if( GetMCAnalysisUtils()->GetDebug() >= 0 )
    (AliAnalysisManager::GetAnalysisManager())->AddClassDebug(GetMCAnalysisUtils()->ClassName(),GetMCAnalysisUtils()->GetDebug());
  
  if( GetIsolationCut()->GetDebug() >= 0 )
    (AliAnalysisManager::GetAnalysisManager())->AddClassDebug(GetIsolationCut()   ->ClassName(),GetIsolationCut()->GetDebug());
  
  //printf("Debug levels: Ana %d, MC %d, Iso %d\n",fDebug,GetMCAnalysisUtils()->GetDebug(),GetIsolationCut()->GetDebug());

}

//_________________________________________________
void AliAnaCaloTrackCorrBaseClass::InitParameters()
{ 
  //Initialize the parameters of the analysis.
  fDataMC              = kFALSE;
  fDebug               = 0;
  fCheckCaloPID        = kTRUE ;
  fCheckFidCut         = kFALSE ;
  fCheckRealCaloAcc    = kFALSE ;
  fRecalculateCaloPID  = kFALSE ;
  fMinPt               = 0.2  ; //Min pt in particle analysis
  fMaxPt               = 300. ; //Max pt in particle analysis
  fNZvertBin           = 1;
  fNrpBin              = 1;
  
  fCalorimeterString   = "EMCAL";
  fCalorimeter         = kEMCAL ;
  
  fTrackMultBins[0] =  0;  fTrackMultBins[1] =  5;  fTrackMultBins[2] = 10;
  fTrackMultBins[3] = 15;  fTrackMultBins[4] = 20;  fTrackMultBins[5] = 30;
  fTrackMultBins[6] = 40;  fTrackMultBins[7] = 55;  fTrackMultBins[8] = 70;
  for(Int_t ibin=9; ibin < 20; ibin++) fTrackMultBins[ibin] = 10000;
  
  //fReader    = new AliCaloTrackReader(); //Initialized in maker
  //fCaloUtils = new AliCalorimeterUtils();//Initialized in maker
  
  fNewAOD              = kFALSE ;
  fOutputAODName       = "CaloTrackCorr";
  fOutputAODClassName  = "AliAODPWG4Particle";
  fInputAODName        = "CaloTrackCorr";
  fAddToHistogramsName = "";
  fAODObjArrayName     = "Ref";
  
}

//__________________________________________________________________
void AliAnaCaloTrackCorrBaseClass::Print(const Option_t * opt) const
{
  //Print some relevant parameters set for the analysis
  
  if(! opt)
    return;
	
  printf("New AOD:            =     %d\n",      fNewAOD);
  printf("Input AOD name:     =     %s\n",      fInputAODName.Data());
  printf("Output AOD name:    =     %s\n",      fOutputAODName.Data());
  printf("Output AOD Class name: =  %s\n",      fOutputAODClassName.Data());
  printf("Name of reference array      : %s\n", fAODObjArrayName.Data());
  printf("String added histograms name : %s\n", fAddToHistogramsName.Data());

  printf("Min Photon pT       =     %2.2f\n", fMinPt) ;
  printf("Max Photon pT       =     %3.2f\n", fMaxPt) ;
  printf("Check PID           =     %d\n",    fCheckCaloPID) ;
  printf("Recalculate PID     =     %d\n",    fRecalculateCaloPID) ;
  printf("Check Fiducial cut  =     %d\n",    fCheckFidCut) ;
  printf("Check Real Calo Acc =     %d\n",    fCheckRealCaloAcc) ;
  printf("Check MC labels     =     %d\n",    fDataMC);
  printf("Make plots?         =     %d\n",    fMakePlots);
  printf("Debug Level         =     %d\n",    fDebug);
  
  printf("    \n") ;
  
} 

//_______________________________________________________________
void AliAnaCaloTrackCorrBaseClass::SetCalorimeter(TString & calo)
{
  // Set the calorimeter for the analysis
  
  fCalorimeterString = calo;
  
  if     (calo=="EMCAL") fCalorimeter = kEMCAL;
  else if(calo=="PHOS" ) fCalorimeter = kPHOS;
  else if(calo=="CTS")   fCalorimeter = kCTS;
  else if(calo=="DCAL")  fCalorimeter = kDCAL;
  else if(calo.Contains("DCAL") && calo.Contains("PHOS")) fCalorimeter = kDCALPHOS;
  else AliFatal(Form("Detector < %s > not known!", calo.Data()));

}

//___________________________________________________________
void AliAnaCaloTrackCorrBaseClass::SetCalorimeter(Int_t calo)
{
  // Set the calorimeter for the analysis
  
  fCalorimeter = calo;
  
  if     (calo==kEMCAL)    fCalorimeterString = "EMCAL";
  else if(calo==kPHOS )    fCalorimeterString = "PHOS";
  else if(calo==kCTS)      fCalorimeterString = "CTS";
  else if(calo==kDCAL)     fCalorimeterString = "DCAL";
  else if(calo==kDCALPHOS) fCalorimeterString = "DCAL_PHOS";
  else AliFatal(Form("Detector < %d > not known!", calo));

}