Bool_t  kPrint         = kFALSE;
Bool_t  kSimulation    = kFALSE;
Bool_t  kUseKinematics = kFALSE;
Bool_t  kOutputAOD     = kFALSE;
Bool_t  kEventSelection= kFALSE;
Bool_t  kExotic        = kTRUE;
Bool_t  kNonLinearity  = kFALSE;
Int_t   kYears         = 2011;
TString kCollisions    = "pp";
TString kTrig          = "EMC7" ;
TString kClusterArray  = "";
TString kData          = ""; // MC or deltaAOD
TString kInputDataType = "ESD";
TString kCalorimeter   = "EMCAL";
Bool_t  kTM            = kTRUE;
Bool_t  kRecalTM       = kTRUE;
Int_t   kMinCen        = -1;
Int_t   kMaxCen        = -1;
TString kName          = "";
Int_t   kDebug         = -1; 
Float_t kVzCut         = 10.;
Bool_t  kPrimaryVertex = kTRUE;
Bool_t  kUseOADB       = kTRUE;
Bool_t  kTender        = kFALSE;


AliAnalysisTaskCaloTrackCorrelation *AddTaskPi0(const TString data          = "",
                                                const TString calorimeter   = "EMCAL", 
                                                const Bool_t  simulation    = kFALSE,
                                                const Bool_t  eventsel      = kFALSE,
                                                const Float_t vzcut         = 10,
                                                const Bool_t  primver       = kTRUE,
                                                const Bool_t  oadb          = kTRUE,
                                                const Bool_t  exotic        = kTRUE,
                                                const Bool_t  nonlin        = kFALSE,
                                                TString       outputfile    = "",
                                                const Int_t   year          = 2012,
                                                const TString col           = "pp", 
                                                const TString trigger       = "MB", 
                                                const TString clustersArray = "V1",
                                                const Bool_t  recaltm       = kTRUE,
                                                const Bool_t  tm            = kTRUE,
                                                const Int_t   minCen        = -1,
                                                const Int_t   maxCen        = -1,
                                                const Bool_t  qaan          = kFALSE,
                                                const Bool_t  splitan       = kFALSE,
                                                const Bool_t  tender        = kFALSE,
                                                const Bool_t  outputAOD     = kFALSE, 
                                                const Bool_t  printSettings = kFALSE,
                                                const Double_t scaleFactor   = -1
                                                )
{
  // Creates a CaloTrackCorr task, configures it and adds it to the analysis manager.
  
  kPrint         = printSettings;
  kSimulation    = simulation;
  kYears         = year;
  kCollisions    = col;
  kExotic        = exotic;
  kNonLinearity  = nonlin;
  kTrig          = trigger;
  kClusterArray  = clustersArray;
  kData          = data;
  kCalorimeter   = calorimeter;
  kOutputAOD     = outputAOD;
  kTM            = tm;
  kRecalTM       = recaltm;
  kMinCen        = minCen;
  kMaxCen        = maxCen;
  kEventSelection= eventsel;
  kVzCut         = vzcut;
  kPrimaryVertex = primver;
  kUseOADB       = oadb;
  kTender        = tender;

  // Get the pointer to the existing analysis manager via the static access method.
  
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) 
  {
    ::Error("AddTask", "No analysis manager to connect to.");
    return NULL;
  }  
  
  // Check the analysis type using the event handlers connected to the analysis manager.
  
  if (!mgr->GetInputEventHandler()) 
  {
    ::Error("AddTask", "This task requires an input event handler");
    return NULL;
  }
  
  kInputDataType = "AOD";
  if(!kData.Contains("delta"))
    kInputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
  
  if(kSimulation) 
  { 
    kUseKinematics = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE; 
    if (!kUseKinematics && data=="AOD" && kInputDataType != "ESD") kUseKinematics = kTRUE; //AOD primary should be available ... 
  } 
  
  cout<<"********* ACCESS KINE? "<<kUseKinematics<<endl;
  
  // Name for containers
  
  kName = Form("%s_Trig%s_Cl%s_TM%d",kCalorimeter.Data(), kTrig.Data(),kClusterArray.Data(),kTM);

  if(kCollisions=="PbPb" && kMaxCen>=0) kName+=Form("Cen%d_%d",kMinCen,kMaxCen);
    
  printf("<<<< NAME: %s >>>>>\n",kName.Data());
  
  // #### Configure analysis ####
    
  AliAnaCaloTrackCorrMaker * maker = new AliAnaCaloTrackCorrMaker();
  
  maker->SetScaleFactor(scaleFactor); // for MC, negative (not scaled) by default
  
  // General frame setting and configuration
  maker->SetReader   (ConfigureReader()   ); 
  maker->SetCaloUtils(ConfigureCaloUtils()); 
  
  // Analysis tasks setting and configuration
  Int_t n = 0;//Analysis number, order is important  
  
  maker->AddAnalysis(ConfigurePhotonAnalysis(), n++); // Photon cluster selection
  maker->AddAnalysis(ConfigurePi0Analysis(), n++); // Pi0 invariant mass accumulate 
  maker->AddAnalysis(ConfigurePi0EbEAnalysis("Pi0", AliAnaPi0EbE::kIMCalo), n++); // Pi0 event by event selection, and photon tagging from decay    

  if(qaan)                  maker->AddAnalysis(ConfigureQAAnalysis(),n++);
  if(splitan && 
     kCalorimeter=="EMCAL") maker->AddAnalysis(ConfigureInClusterIMAnalysis(0.5,3), n++); 
  
  maker->SetAnaDebug(kDebug)  ;
  maker->SwitchOnHistogramsMaker()  ;
  if(kData.Contains("delta")) maker->SwitchOffAODsMaker() ;
  else                        maker->SwitchOnAODsMaker()  ;
  
  if(kPrint) maker->Print("");
  
  printf("<< End Configuration of %d analysis for calorimeter %s >>\n",n, kCalorimeter.Data());

  // Create task
  
  AliAnalysisTaskCaloTrackCorrelation * task = new AliAnalysisTaskCaloTrackCorrelation (Form("CaloTrackCorr%s",kName.Data()));
  task->SetConfigFileName(""); //Don't configure the analysis via configuration file.
  task->SetDebugLevel(kDebug);
  task->SetBranches("ESD:AliESDRun.,AliESDHeader"); 
  task->SetAnalysisMaker(maker);
  mgr->AddTask(task);
  
  //Create containers
  
  if(outputfile.Length()==0) outputfile = AliAnalysisManager::GetCommonFileName(); 
  
  AliAnalysisDataContainer *cout_pc   = mgr->CreateContainer(kName, TList::Class(), 
                                                             AliAnalysisManager::kOutputContainer, 
                                                             Form("%s",outputfile.Data()));
	
  AliAnalysisDataContainer *cout_cuts = mgr->CreateContainer(Form("Param_%s",kName.Data()), TList::Class(), 
                                                             AliAnalysisManager::kParamContainer, 
                                                             "AnalysisParameters.root");
  
  // Create ONLY the output containers for the data produced by the task.
  // Get and connect other common input/output containers via the manager as below
  //==============================================================================
  mgr->ConnectInput  (task, 0, mgr->GetCommonInputContainer());
  // AOD output slot will be used in a different way in future
  if(!kData.Contains("delta")   && outputAOD) mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
  mgr->ConnectOutput (task, 1, cout_pc);
  mgr->ConnectOutput (task, 2, cout_cuts);
  
  
  if(kTrig=="EMC7")
  {
    printf("Pi0 analysis, trigger EMC7\n");
    task->SelectCollisionCandidates(AliVEvent::kEMC7);
  }
  else if (kTrig=="INT7")
  {
    printf("Pi0 analysis, trigger INT7\n");
    task->SelectCollisionCandidates(AliVEvent::kINT7);
  }
  else if(kTrig=="EMC1")
  {
    printf("Pi0 analysis, trigger EMC1\n");
    task->SelectCollisionCandidates(AliVEvent::kEMC1);
  }
  else if(kTrig=="MB")
  {
    printf("Pi0 analysis, trigger MB\n");
    task->SelectCollisionCandidates(AliVEvent::kMB);
  }  
  else if(kTrig=="PHOS")
  {
    printf("Pi0 analysis, trigger PHOS\n");
    task->SelectCollisionCandidates(AliVEvent::kPHI7);
  }  
  else if(kTrig=="PHOSPb")
  {
    printf("Pi0 analysis, trigger PHOSPb\n");
    task->SelectCollisionCandidates(AliVEvent::kPHOSPb);
  }
  else if(kTrig=="AnyINT")
  {
    printf("Pi0 analysis, trigger AnyINT\n");
    task->SelectCollisionCandidates(AliVEvent::kAnyINT);
  }  
  else if(kTrig=="INT")
  {
    printf("Pi0 analysis, trigger AnyINT\n");
    task->SelectCollisionCandidates(AliVEvent::kAny);
  }
  else if(kTrig=="EMCEGA")
  {
    printf("Pi0 analysis, trigger EMC Gamma\n");
    task->SelectCollisionCandidates(AliVEvent::kEMCEGA);
  } 
  else if(kTrig=="EMCEJE")
  {
    printf("Pi0 analysis, trigger EMC Jet\n");
    task->SelectCollisionCandidates(AliVEvent::kEMCEJE);
  }
  else if(kTrig=="Central")
  {
    printf("Pi0 analysis, trigger Central\n");
    task->SelectCollisionCandidates(AliVEvent::kCentral);
  } 
  else if(kTrig=="SemiCentral")
  {
    printf("Pi0 analysis, trigger SemiCentral\n");
    task->SelectCollisionCandidates(AliVEvent::kSemiCentral);
  }
  else if(kTrig=="SemiOrCentral")
  {
    printf("Pi0 analysis, trigger SemiCentral Or Central\n");
    task->SelectCollisionCandidates(AliVEvent::kSemiCentral | AliVEvent::kCentral);
  }
  
  
  return task;
}

//____________________________________
AliCaloTrackReader * ConfigureReader()
{
  
  AliCaloTrackReader * reader = 0;
  if     (kInputDataType == "ESD"&& kData=="MC" ) 
    reader = new AliCaloTrackMCReader();
  else if(kInputDataType=="AOD" || kData.Contains("AOD"))   
    reader = new AliCaloTrackAODReader();
  else if(kInputDataType=="ESD")            
    reader = new AliCaloTrackESDReader();
  else 
    printf("AliCaloTrackReader::ConfigureReader() - Data combination not known kData=%s, kInputData=%s\n",kData.Data(),kInputDataType.Data());
  
  
  reader->SetDebug(kDebug);//10 for lots of messages
  
  //Delta AOD?
  //reader->SetDeltaAODFileName("");
  if(kOutputAOD) reader->SwitchOnWriteDeltaAOD()  ;
  
  // MC settings
  if(kUseKinematics){
    if(kInputDataType == "ESD"){
      reader->SwitchOnStack();          
      reader->SwitchOffAODMCParticles(); 
    }
    else if(kInputDataType == "AOD"){
      reader->SwitchOffStack();          
      reader->SwitchOnAODMCParticles(); 
    }
  }  
  
  //------------------------
  // Detector input filling
  //------------------------
  
  //Min cluster/track E
  reader->SetEMCALEMin(0.3); 
  reader->SetEMCALEMax(1000); 
  reader->SetPHOSEMin(0.3);
  reader->SetPHOSEMax(1000);
  reader->SetCTSPtMin(0.2);
  reader->SetCTSPtMax(1000);
  
  if(!kSimulation && kCalibT) reader->SetEMCALTimeCut(-30,30); 
  else                        reader->SetEMCALTimeCut(-1000,1000); // Open time cut
  
  reader->SwitchOnFiducialCut();
  reader->GetFiducialCut()->SetSimpleCTSFiducialCut(0.8, 0, 360) ;

  // Tracks
  reader->SwitchOffCTS();
  
  // Calorimeter
  
  reader->SetEMCALClusterListName(kClusterArray);
  if(kClusterArray == "" && !kTender) 
  {
    printf("**************** Standard EMCAL clusters branch analysis **************** \n");
    reader->SwitchOnClusterRecalculation();
    // Check in ConfigureCaloUtils that the recalibration and bad map are ON 
  }
  else 
  {
    printf("**************** Input for analysis is Clusterizer %s **************** \n", kClusterArray.Data());
    reader->SwitchOffClusterRecalculation();
  }  
  
  //if(kCalorimeter == "EMCAL") {
    reader->SwitchOnEMCALCells();  
    reader->SwitchOnEMCAL();
  //}
  //if(kCalorimeter == "PHOS") { 
    reader->SwitchOnPHOSCells();  
    reader->SwitchOnPHOS();
  //}
  
  // for case data="deltaAOD", no need to fill the EMCAL/PHOS cluster lists
  if(kData.Contains("delta")){
    reader->SwitchOffEMCAL();
    reader->SwitchOffPHOS();
    reader->SwitchOffEMCALCells(); 
    reader->SwitchOffPHOSCells(); 
  }
  
  //-----------------
  // Event selection
  //-----------------
  
  if(!kUseKinematics && kTrig.BeginsWith("C")) reader->SetFiredTriggerClassName(kTrig); 
  
  // vertex event selection
  reader->SetZvertexCut(kVzCut);               
  if(kPrimaryVertex)reader->SwitchOnPrimaryVertexSelection(); 
  else              reader->SwitchOffPrimaryVertexSelection(); 
  
  if(kEventSelection)
  {
    reader->SwitchOnPileUpEventRejection();   // remove pileup by default
    reader->SwitchOnV0ANDSelection() ;        // and besides v0 AND
  }
  else 
  {
    reader->SwitchOffPileUpEventRejection();  // remove pileup by default
    reader->SwitchOffV0ANDSelection() ;       // and besides v0 AND
  }
    
  if(kCollisions=="PbPb") 
  {
    // Centrality
    reader->SetCentralityClass("V0M");
    reader->SetCentralityOpt(10);  // 10 (c= 0-10, 10-20 ...), 20  (c= 0-5, 5-10 ...) or 100 (c= 1, 2, 3 ..)
    reader->SetCentralityBin(kMinCen,kMaxCen); // Accept all events, if not select range
    
    // Event plane (only used in AliAnaPi0 for the moment)
    reader->SetEventPlaneMethod("Q");
  }
    
  if(kPrint) reader->Print("");
  
  return reader;
  
}

//_______________________________________
AliCalorimeterUtils* ConfigureCaloUtils()
{
  
  AliCalorimeterUtils *cu = new AliCalorimeterUtils;
  cu->SetDebug(kDebug);
  
  // Remove clusters close to borders, at least max energy cell is 1 cell away 
  cu->SetNumberOfCellsFromEMCALBorder(1);
  cu->SetNumberOfCellsFromPHOSBorder(2);
  
  // Search of local maxima in cluster
  if(kCollisions=="pp")
  {
    cu->SetLocalMaximaCutE(0.1);
    cu->SetLocalMaximaCutEDiff(0.03);
  }
  else 
  {
    cu->SetLocalMaximaCutE(0.2);
    cu->SetLocalMaximaCutEDiff(0.03);
  }
  
  cu->SwitchOffClusterPlot();

  if(kRecalTM) cu->SwitchOnRecalculateClusterTrackMatching(); // Done in clusterization
  else         cu->SwitchOffRecalculateClusterTrackMatching();
  
  
  //EMCAL settings

  if(!kSimulation)
    cu->SwitchOnLoadOwnEMCALGeometryMatrices();
  
  AliEMCALRecoUtils * recou = cu->GetEMCALRecoUtils();
  
  Bool_t bCalibE = kTRUE;
  Bool_t bCalibT = kTRUE;
  Bool_t bBadMap = kTRUE;
  
  if(kUseOADB)
  {
    cu->SwitchOnRecalibration(); 
    cu->SwitchOnBadChannelsRemoval() ;
    cu->SwitchOnEMCALOADB();
  }
  else
  {
    cu->SwitchOffRecalibration(); 
    cu->SwitchOffBadChannelsRemoval() ;
    cu->SwitchOffEMCALOADB();
    bCalibE = kFALSE;
    bBadMap = kFALSE;
    bCalibT = kFALSE;
  }
  
  gROOT->LoadMacro("$ALICE_ROOT/PWGGA/EMCALTasks/macros/ConfigureEMCALRecoUtils.C");
  ConfigureEMCALRecoUtils(recou,
                          kSimulation,                             
                          kExotic,
                          kNonLinearity,
                          bCalibE, 
                          bBadMap,
                          bCalibT);   
  

  printf("ConfigureCaloUtils() - EMCAL Recalibration ON? %d %d\n",recou->IsRecalibrationOn(), cu->IsRecalibrationOn());
  printf("ConfigureCaloUtils() - EMCAL BadMap        ON? %d %d\n",recou->IsBadChannelsRemovalSwitchedOn(), cu->IsBadChannelsRemovalSwitchedOn());
  
 
  
  if( kNonLinearity ) 
  { 
    printf("ConfigureCaloUtils() - Apply non linearity to EMCAL\n");
    cu->SwitchOnCorrectClusterLinearity();
  }
  
  if(kCalorimeter=="PHOS")
  {
    if (kYears <  2014) cu->SetNumberOfSuperModulesUsed(3);
    else                cu->SetNumberOfSuperModulesUsed(4);
  }
  else
  {
    if      (kYears == 2010) cu->SetNumberOfSuperModulesUsed(4); //EMCAL first year
    else if (kYears <  2014) cu->SetNumberOfSuperModulesUsed(10);
    else                     cu->SetNumberOfSuperModulesUsed(20);
  }
  
  // PHOS 
  cu->SwitchOffLoadOwnPHOSGeometryMatrices();
    
  if(kPrint) cu->Print("");
  
  return cu;
  
}

//_____________________________________
AliAnaPhoton* ConfigurePhotonAnalysis()
{
  
  AliAnaPhoton *ana = new AliAnaPhoton();
  ana->SetDebug(kDebug); //10 for lots of messages
  
  // cluster selection cuts
  
  ana->SwitchOffFiducialCut();

  ana->SetCalorimeter(kCalorimeter);
  
  if(kCalorimeter == "PHOS")
  {
    ana->SetNCellCut(2);// At least 3 cells
    ana->SetMinPt(0.3);
    ana->SetMinDistanceToBadChannel(2, 4, 5);
    ana->SetTimeCut(-2000,2000); // open cut
  }
  else 
  {//EMCAL
    ana->SetNCellCut(1);// At least 2 cells
    ana->SetMinEnergy(0.3); // avoid mip peak at E = 260 MeV
    ana->SetMaxEnergy(1000); 
    ana->SetTimeCut(-1000,1000); // open cut, usual time window of [425-825] ns if time recalibration is off 
    // restrict to less than 100 ns when time calibration is on 
    ana->SetMinDistanceToBadChannel(2, 4, 6); 
  }
  
  if(kTM)
  {
    ana->SwitchOnTrackMatchRejection() ;
    ana->SwitchOffTMHistoFill() ;
  }
  else
  {
    ana->SwitchOffTrackMatchRejection() ;
    ana->SwitchOnTMHistoFill() ;
  }
  
  //PID cuts (shower shape)
  ana->SwitchOnCaloPID(); // do PID selection, unless specified in GetCaloPID, selection not based on bayesian
  AliCaloPID* caloPID = ana->GetCaloPID();
  //Not used in bayesian
  
  //EMCAL
  caloPID->SetEMCALLambda0CutMax(0.50); // Mild cut
  caloPID->SetEMCALLambda0CutMin(0.10);
  
  caloPID->SetEMCALDEtaCut(0.025);
  caloPID->SetEMCALDPhiCut(0.030);
  
  //PHOS
  caloPID->SetPHOSDispersionCut(2.5);
  caloPID->SetPHOSRCut(2.);
  if(kInputData=="AOD") caloPID->SetPHOSRCut(2000.); // Open cut since dX, dZ not stored
      
  ana->SwitchOffFillShowerShapeHistograms();  // Filled before photon shower shape selection
  
  // Input / output delta AOD settings
  
  if(!kData.Contains("delta")) 
  {
    ana->SetOutputAODName(Form("Photon%s",kName.Data()));
    ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
    //ana->SetOutputAODClassName("AliAODPWG4Particle"); // use if no correlation done
  }
  else ana->SetInputAODName(Form("Photon%s",kName.Data()));
  
  //Set Histograms name tag, bins and ranges
  
  ana->AddToHistogramsName(Form("AnaPhoton_TM%d_",kTM));
  SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
  
  // Number of particle type MC histograms
  ana->FillNOriginHistograms(8);
  ana->FillNPrimaryHistograms(4);
  
  ConfigureMC(ana);
  
  if(kPrint) ana->Print("");
  
  return ana;
  
}

//__________________________________________________________________________________________
AliAnaInsideClusterInvariantMass* ConfigureInClusterIMAnalysis(Float_t l0min, Float_t l0max)
{

  AliAnaInsideClusterInvariantMass *ana = new AliAnaInsideClusterInvariantMass();
  ana->SetDebug(kDebug); //10 for lots of messages
  
  // selection cuts
  
  ana->SetMinEnergy(5); 
  ana->SetMaxEnergy(200.);   
  ana->SetMinNCells(3);
  ana->SetM02Cut(l0min,l0max);
  ana->SetCalorimeter(kCalorimeter);
  
  //ana->AddToHistogramsName(Form("AnaInClusterIM_%1.2f_%1.2f_",l0min,l0max));
  ana->AddToHistogramsName("AnaInClusterIM_");

  SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
  
  AliCaloPID* caloPID = ana->GetCaloPID();
  caloPID->SetEMCALDEtaCut(0.025);
  caloPID->SetEMCALDPhiCut(0.030);
  caloPID->SetClusterSplittingM02Cut(0,100); // Do the selection in the analysis class and not in the PID method to fill SS histograms

  caloPID->SetPi0MassRange(0.10, 0.18);
  caloPID->SetEtaMassRange(0.40, 0.60);
  caloPID->SetPhotonMassRange(0.00, 0.08);  
  
  ConfigureMC(ana);
  
  if(kPrint) ana->Print("");
  
  return ana;
  
}

//_______________________________
AliAnaPi0* ConfigurePi0Analysis()
{
  
  AliAnaPi0 *ana = new AliAnaPi0();
  
  ana->SetDebug(kDebug);//10 for lots of messages
  
  // Input delta AOD settings
  ana->SetInputAODName(Form("Photon%s",kName.Data()));
  
  // Calorimeter settings
  ana->SetCalorimeter(kCalorimeter);
  
  //settings for pp collision mixing
  ana->SwitchOnOwnMix(); //Off when mixing done with general mixing frame
  
  // Cuts 
  if(kCalorimeter=="EMCAL") ana->SetPairTimeCut(40);
  
  ana->SetNAsymCuts(1); // no asymmetry cut, previous studies showed small effect. 
  //In EMCAL assymetry cut prevents combination of assymetric decays which is the main source of pi0 at high E.
  
  if     (kCollisions=="pp"  ) 
  {
    ana->SetNCentrBin(1);
    ana->SetNZvertBin(10);
    ana->SetNRPBin(1);
    ana->SetNMaxEvMix(100);    
    ana->SwitchOnSMCombinations();
  }
  else if(kCollisions=="PbPb") 
  {
    ana->SetNCentrBin(10);
    ana->SetNZvertBin(10);
    ana->SetNRPBin(4);
    ana->SetNMaxEvMix(10);
    ana->SwitchOffSMCombinations();
  }

  ana->SwitchOffMultipleCutAnalysis();

  //Set Histograms name tag, bins and ranges
  
  ana->AddToHistogramsName(Form("AnaPi0_TM%d_",kTM));
  SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below

  ConfigureMC(ana);
  
  if(kPrint) ana->Print("");
  
  return ana;
  
}

//_____________________________________________________
AliAnaPi0EbE* ConfigurePi0EbEAnalysis(TString particle, 
                                      Int_t analysis)
{
  
  AliAnaPi0EbE *ana = new AliAnaPi0EbE();
  ana->SetDebug(kDebug);//10 for lots of messages
  
  ana->SetAnalysisType(analysis);
  TString opt = "";
  if(analysis==AliAnaPi0EbE::kIMCaloTracks) opt = "Conv";
  if(analysis==AliAnaPi0EbE::kSSCalo)       opt = "SS";
  
  ana->SetMinPt(0.5);
  
  if(kCalorimeter=="EMCAL")ana->SetPairTimeCut(15); // More strict than in pi0 inv mass analysis
  
  ana->SetCalorimeter(kCalorimeter);
  
  // Input / output delta AOD settings
  
  ana->SetInputAODName(Form("Photon%s",kName.Data()));
  if(!kInputDataType.Contains("delta")) 
  {
    ana->SetOutputAODName(Form("%s%s%s",particle.Data(), opt.Data(), kName.Data()));
    ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
  }
  else  
    ana->SetInputAODName(Form("%s%s%s",particle.Data(),opt.Data(),kName.Data()));
  
  if(analysis == AliAnaPi0EbE::kIMCaloTracks) ana->SetInputAODGammaConvName("PhotonsCTS");
  
  if(analysis!=AliAnaPi0EbE::kSSCalo)
  {
    AliNeutralMesonSelection *nms = ana->GetNeutralMesonSelection();
    nms->SetParticle(particle);
    
    // Tighten a bit mass cut with respect to default window
    if(particle=="Pi0") nms->SetInvMassCutRange(0.120,0.150);
    if(particle=="Eta") nms->SetInvMassCutRange(0.520,0.580);    
    
    nms->SwitchOnAngleSelection();
    nms->KeepNeutralMesonSelectionHistos(kTRUE);
    //nms->SetAngleMaxParam(2,0.2);
    nms->SetHistoERangeAndNBins(0, 20, 80) ;
    //nms->SetHistoIMRangeAndNBins(0, 1, 400);
  }
  else
  { // cluster splitting settings
    ana->SetTimeCut(-1000,1000); // Open time cut
    AliCaloPID* caloPID = ana->GetCaloPID();
    caloPID->SetPi0MassRange(0.10, 0.18);
    caloPID->SetEtaMassRange(0.40, 0.60);
    caloPID->SetPhotonMassRange(0.00, 0.08);
    caloPID->SetClusterSplittingM02Cut(0.5,100); // Do the selection in the analysis class and not in the PID method to fill SS histograms
  }
  
  ana->SwitchOffSelectedClusterHistoFill(); 
  ana->SwitchOffFillWeightHistograms();
  
  if(!kTM) ana->SwitchOnTMHistoFill();
  else     ana->SwitchOffTMHistoFill();
  
  //Set Histograms name tag, bins and ranges
  
  ana->AddToHistogramsName(Form("Ana%s%sEbE_TM%d_",particle.Data(),opt.Data(),kTM));
  SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
  
  ConfigureMC(ana);
  
  if(kPrint) ana->Print("");
  
  return  ana;
  
}

//________________________________________
AliAnaCalorimeterQA* ConfigureQAAnalysis()
{
  
  AliAnaCalorimeterQA *ana = new AliAnaCalorimeterQA();
  ana->SetDebug(kDebug); //10 for lots of messages
  ana->SetCalorimeter(kCalorimeter);
  
  ana->SetTimeCut(-1000,1000); // Open time cut
  
  // Study inter detector correlation (PHOS, EMCAL, Tracks, V0)
  if(kCalorimeter=="PHOS" && kTrig=="PHOS"){
    ana->SwitchOnCorrelation(); // make sure you switch in the reader PHOS and EMCAL cells and clusters if option is ON
  }
  if(kCalorimeter=="EMCAL" && kClusterArray==""){
    ana->SwitchOnCorrelation(); // make sure you switch in the reader PHOS and EMCAL cells and clusters if option is ON
  }
  else {
    ana->SwitchOffCorrelation();
  }
  
  // Study exotic clusters PHOS and EMCAL
  if(kClusterArray==""){
    ana->SwitchOnStudyBadClusters() ; 
  }
  else {
    ana->SwitchOffStudyBadClusters() ;
  }
  
  ana->SwitchOffFiducialCut();
  ana->SwitchOffFillAllTH3Histogram();
  ana->SwitchOffFillAllPositionHistogram();
  ana->SwitchOffFillAllPositionHistogram2();
  if(!kExotic)ana->SwitchOnStudyBadClusters();
  else        ana->SwitchOffStudyBadClusters();
  ana->SwitchOffStudyClustersAsymmetry();
  ana->SwitchOffStudyWeight();
  ana->SwitchOnFillAllTrackMatchingHistogram();
  
  ana->AddToHistogramsName("QA_"); //Begining of histograms name
  SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
  
  ConfigureMC(ana);
  
  if(kPrint) ana->Print("");	
  
  return ana;
  
}

//________________________________________________________
void ConfigureMC(AliAnaCaloTrackCorrBaseClass* ana)
{
  if(kSimulation) ana->SwitchOnDataMC() ;//Access MC stack and fill more histograms, AOD MC not implemented yet.
  else            ana->SwitchOffDataMC() ;

  //Set here generator name, default pythia
  //ana->GetMCAnalysisUtils()->SetMCGenerator("");
}  

//________________________________________________________
void SetHistoRangeAndNBins (AliHistogramRanges* histoRanges)
{
  // Set common bins for all analysis and MC histograms filling
    
  histoRanges->SetHistoPtRangeAndNBins(0, 100, 200) ; // Energy and pt histograms
  
  if(kCalorimeter=="EMCAL")
  {
    if(kYears==2010)
    {
      histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 122*TMath::DegToRad(), 78) ;
      histoRanges->SetHistoXRangeAndNBins(-230,90,120); // QA
      histoRanges->SetHistoYRangeAndNBins(370,450,40);  // QA
    }
    else if(kYears==2011)
    {           
      histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 182*TMath::DegToRad(), 108) ;
      histoRanges->SetHistoXRangeAndNBins(-600,90,200); // QA
      histoRanges->SetHistoYRangeAndNBins(100,450,100); // QA
    }
    else
    {
      histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 190*TMath::DegToRad(), 122) ;
      histoRanges->SetHistoXRangeAndNBins(-100,90,200); // QA
      histoRanges->SetHistoYRangeAndNBins(50,450,100);  // QA
    }

    histoRanges->SetHistoEtaRangeAndNBins(-0.72, 0.72, 144) ;
  }
  else
  {
    histoRanges->SetHistoPhiRangeAndNBins(260*TMath::DegToRad(), 320*TMath::DegToRad(), 60) ;
    histoRanges->SetHistoEtaRangeAndNBins(-0.13, 0.13, 130) ;
  }
  
  histoRanges->SetHistoShowerShapeRangeAndNBins(0, 5, 500);
  
  // Invariant mass histoRangeslysis
  histoRanges->SetHistoMassRangeAndNBins(0., 1., 200) ;
  histoRanges->SetHistoAsymmetryRangeAndNBins(0., 1. , 100) ;
  
  // check if time calibration is on
  histoRanges->SetHistoTimeRangeAndNBins(-1000.,1000,1000);
  histoRanges->SetHistoDiffTimeRangeAndNBins(-200, 200, 800);
  
  // track-cluster residuals
  histoRanges->SetHistoTrackResidualEtaRangeAndNBins(-0.15,0.15,300);
  histoRanges->SetHistoTrackResidualPhiRangeAndNBins(-0.15,0.15,300);

  // QA, electron, charged
  histoRanges->SetHistoPOverERangeAndNBins(0,10.,100);
  histoRanges->SetHistodEdxRangeAndNBins(0.,200.,200);
  
  // QA
  histoRanges->SetHistoFinePtRangeAndNBins(0, 10, 200) ; // bining for fhAmpId
  histoRanges->SetHistodRRangeAndNBins(0.,TMath::Pi(),150);
  histoRanges->SetHistoRatioRangeAndNBins(0.,2.,100);
  histoRanges->SetHistoVertexDistRangeAndNBins(0.,500.,500);
  histoRanges->SetHistoNClusterCellRangeAndNBins(0,500,500);
  histoRanges->SetHistoZRangeAndNBins(-400,400,200);
  histoRanges->SetHistoRRangeAndNBins(400,450,25);
  histoRanges->SetHistoV0SignalRangeAndNBins(0,5000,500);
  histoRanges->SetHistoV0MultiplicityRangeAndNBins(0,5000,500);
  histoRanges->SetHistoTrackMultiplicityRangeAndNBins(0,5000,500);
  
}