PWGGA/CaloTrackCorrelations/macros/AddTaskCaloTrackCorr.C

   1
   2 Bool_t  kPrint         = kFALSE;
   3 Bool_t  kSimulation    = kFALSE;
   4 Bool_t  kUseKinematics = kFALSE;
   5 Bool_t  kOutputAOD     = kFALSE;
   6 Bool_t  kEventSelection= kFALSE;
   7 Bool_t  kExotic        = kTRUE;
   8 Bool_t  kNonLinearity  = kFALSE;
   9 Int_t   kYears         = 2011;
  10 TString kCollisions    = "pp";
  11 TString kTrig          = "EMC7" ;
  12 TString kClusterArray  = "";
  13 TString kData          = ""; // MC or deltaAOD
  14 TString kInputDataType = "ESD";
  15 TString kCalorimeter   = "EMCAL";
  16 Bool_t  kTM            = kTRUE;
  17 Bool_t  kRecalTM       = kTRUE;
  18 Int_t   kMinCen        = -1;
  19 Int_t   kMaxCen        = -1;
  20 TString kName          = "";
  21 Int_t   kDebug         = -1;
  22 Bool_t  kQA            = kFALSE;
  23 Bool_t  kHadronAN      = kFALSE;
  24 Bool_t  kCalibE        = kTRUE;
  25 Bool_t  kCalibT        = kTRUE;
  26 Bool_t  kBadMap        = kTRUE;
  27 Bool_t  kTender        = kFALSE;
  28 Bool_t  kMix           = kFALSE;
  29
  30 AliAnalysisTaskCaloTrackCorrelation *AddTaskCaloTrackCorr(const TString  data          = "",
  31                                                           const TString  calorimeter   = "EMCAL",
  32                                                           const Bool_t   simulation    = kFALSE,
  33                                                           const Bool_t   eventsel      = kFALSE,
  34                                                           const Bool_t   exotic        = kTRUE,
  35                                                           const Bool_t   nonlin        = kFALSE,
  36                                                           TString        outputfile    = "",
  37                                                           const Int_t    year          = 2010,
  38                                                           const TString  col           = "pp",
  39                                                           const TString  trigger       = "MB",
  40                                                           const TString  clustersArray = "V1",
  41                                                           const Bool_t   mix           = kTRUE,
  42                                                           const Bool_t   recaltm       = kTRUE,
  43                                                           const Bool_t   tm            = kTRUE,
  44                                                           const Int_t    minCen        = -1,
  45                                                           const Int_t    maxCen        = -1,
  46                                                           const Bool_t   qaan          = kFALSE,
  47                                                           const Bool_t   hadronan      = kFALSE,
  48                                                           const Bool_t   calibE        = kTRUE,
  49                                                           const Bool_t   badmap        = kTRUE,
  50                                                           const Bool_t   calibT        = kTRUE,
  51                                                           const Bool_t   tender        = kFALSE,
  52                                                           const Bool_t   outputAOD     = kFALSE,
  53                                                           const Bool_t   printSettings = kFALSE,
  54                                                           const Double_t scaleFactor   = -1
  55                                                           )
  56 {
  57   // Creates a CaloTrackCorr task, configures it and adds it to the analysis manager.
  58
  59   kPrint         = printSettings;
  60   kSimulation    = simulation;
  61   kYears         = year;
  62   kCollisions    = col;
  63   kExotic        = exotic;
  64   kNonLinearity  = nonlin;
  65   kTrig          = trigger;
  66   kClusterArray  = clustersArray;
  67   kData          = data;
  68   kCalorimeter   = calorimeter;
  69   kOutputAOD     = outputAOD;
  70   kTM            = tm;
  71   kRecalTM       = recaltm;
  72   kMinCen        = minCen;
  73   kMaxCen        = maxCen;
  74   kEventSelection= eventsel;
  75   kQA            = qaan;
  76   kHadronAN      = hadronan;
  77   kCalibE        = calibE;
  78   kCalibT        = calibT;
  79   kBadMap        = badmap;
  80   kTender        = tender;
  81   kMix           = mix;
  82
  83   // Get the pointer to the existing analysis manager via the static access method.
  84
  85   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  86   if (!mgr)
  87   {
  88     ::Error("AddTask", "No analysis manager to connect to.");
  89     return NULL;
  90   }
  91
  92   // Check the analysis type using the event handlers connected to the analysis manager.
  93
  94   if (!mgr->GetInputEventHandler())
  95   {
  96     ::Error("AddTask", "This task requires an input event handler");
  97     return NULL;
  98   }
  99
 100   kInputDataType = "AOD";
 101   if(!kData.Contains("delta"))
 102     kInputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
 103
 104   if(kSimulation)
 105   {
 106     kUseKinematics = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
 107     if (!kUseKinematics && data=="AOD" && kInputDataType != "ESD") kUseKinematics = kTRUE; //AOD primary should be available ...
 108   }
 109
 110   cout<<"********* ACCESS KINE? "<<kUseKinematics<<endl;
 111
 112   // Name for containers
 113
 114   kName = Form("%s_Trig%s_Cl%s_TM%d",kCalorimeter.Data(), kTrig.Data(),kClusterArray.Data(),kTM);
 115
 116   if(kCollisions=="PbPb" && kMaxCen>=0) kName+=Form("Cen%d_%d",kMinCen,kMaxCen);
 117
 118   printf("<<<< NAME: %s >>>>>\n",kName.Data());
 119
 120   // #### Configure analysis ####
 121
 122   AliAnaCaloTrackCorrMaker * maker = new AliAnaCaloTrackCorrMaker();
 123
 124   maker->SetScaleFactor(scaleFactor); // for MC, negative (not scaled) by default
 125
 126   // General frame setting and configuration
 127   maker->SetReader   (ConfigureReader()   );
 128   maker->SetCaloUtils(ConfigureCaloUtils());
 129
 130   // Analysis tasks setting and configuration
 131   Int_t n = 0;//Analysis number, order is important
 132
 133   // Isolation settings
 134   Int_t partInCone = AliIsolationCut::kNeutralAndCharged; // kOnlyCharged;
 135   Int_t thresType  = AliIsolationCut::kPtThresIC;//  AliIsolationCut::kSumPtFracIC ;
 136   Float_t cone = -1;
 137   Float_t pth  = -1;
 138
 139   // Photon analysis
 140
 141   maker->AddAnalysis(ConfigurePhotonAnalysis(), n++); // Photon cluster selection
 142
 143   // Invariant mass analysis Put here to tag selected photons as decay
 144   maker->AddAnalysis(ConfigurePi0EbEAnalysis("Pi0", AliAnaPi0EbE::kIMCalo), n++); // Pi0 event by event selection, invariant mass and photon tagging from decay
 145   maker->AddAnalysis(ConfigurePi0EbEAnalysis("Eta", AliAnaPi0EbE::kIMCalo), n++); // Eta event by event selection, invariant mass and photon tagging from decay
 146
 147   // Photon analysis
 148   maker->AddAnalysis(ConfigureIsolationAnalysis("Photon", partInCone,thresType,cone, pth), n++); // Photon isolation
 149   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Photon",kFALSE), n++); // Gamma hadron correlation
 150   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Photon",kTRUE,partInCone,thresType, cone, pth) , n++); // Isolated gamma hadron correlation
 151   //maker->AddAnalysis(ConfigureIsolationAnalysis("Photon", partInCone,thresType,kTRUE), n++); // Photon multi isolation, leave it the last
 152
 153
 154   // Split cluster analysis
 155   if(kCalorimeter == "EMCAL")
 156   {
 157     maker->AddAnalysis(ConfigurePi0EbEAnalysis("Pi0", AliAnaPi0EbE::kSSCalo), n++); // Pi0 event by event selection, cluster splitting
 158     maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0SS", partInCone,thresType,cone, pth), n++);       // Pi0 isolation, cluster splits
 159     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SS" ,kFALSE), n++); // Pi0 hadron correlation
 160     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SS" ,kTRUE,partInCone,thresType, cone, pth) , n++); // Isolated pi0 hadron correlation
 161     //maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0SS",  partInCone,thresType,kTRUE), n++); // Pi0 multi isolation, split cluster
 162     //maker->AddAnalysis(ConfigureInClusterIMAnalysis(0.5,3), n++);
 163   }
 164
 165   // Invariant mass analysis
 166   maker->AddAnalysis(ConfigurePi0EbEAnalysis("Pi0SideBand", AliAnaPi0EbE::kIMCalo), n++); // Pi0 event by event selection, and photon tagging from decay
 167   maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0", partInCone,thresType,cone, pth), n++);         // Pi0 isolation, invariant mass
 168   maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0SideBand", partInCone,thresType,cone, pth), n++); // Pi0 isolation, side band
 169   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0"   ,kFALSE), n++); // Pi0 hadron correlation
 170   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0"   ,kTRUE,partInCone,thresType, cone, pth) , n++); // Isolated pi0 hadron correlation
 171   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SideBand" ,kFALSE), n++); // Pi0 hadron correlation
 172   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SideBand" ,kTRUE,partInCone,thresType, cone, pth) , n++); // Isolated pi0 hadron correlation
 173   //maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0",    partInCone,thresType,kTRUE), n++); // Pi0 multi isolation, invariant mass, leave it the last
 174
 175   if(kHadronAN)
 176   {
 177     maker->AddAnalysis(ConfigureChargedAnalysis(), n++);                                // track selection
 178     maker->AddAnalysis(ConfigureIsolationAnalysis("Hadron",AliIsolationCut::kOnlyCharged,thresType,cone, pth), n++); // track isolation
 179     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Hadron",kFALSE), n++);       // track-track correlation
 180     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Hadron",kTRUE,partInCone,thresType, cone, pth) , n++);       // Isolated track-track correlation
 181     //maker->AddAnalysis(ConfigureIsolationAnalysis("Hadron",partInCone,thresType,kTRUE), n++);// Hadron multi isolation
 182   }
 183
 184   // Analysis with ghost triggers, only for Min Bias like events
 185   if( kTrig.Contains("INT") || kTrig.Contains("Central") || kTrig.Contains("MB")  )
 186   {
 187     maker->AddAnalysis(ConfigureRandomTriggerAnalysis(), n++);
 188     maker->AddAnalysis(ConfigureIsolationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()), partInCone,thresType,cone, pth), n++); // Ghost trigger isolation
 189     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()),kFALSE), n++); // Ghost trigger hadron correlation
 190     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()),kTRUE,partInCone,thresType, cone, pth) , n++); // Isolated ghost hadron correlation
 191     //maker->AddAnalysis(ConfigureIsolationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()), partInCone,thresType,kTRUE), n++); // Ghost multi isolation
 192
 193     if(kHadronAN)
 194     {
 195       maker->AddAnalysis(ConfigureRandomTriggerAnalysis("CTS"), n++);                                // track selection
 196       maker->AddAnalysis(ConfigureIsolationAnalysis("RandomTriggerCTS",AliIsolationCut::kOnlyCharged,thresType,cone, pth), n++); // track isolation
 197       maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("RandomTriggerCTS",kFALSE), n++);       // track-track correlation
 198       maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("RandomTriggerCTS",kTRUE,partInCone,thresType, cone, pth) , n++);       // Isolated track-track correlation
 199       //maker->AddAnalysis(ConfigureIsolationAnalysis("RandomTriggerCTS",AliIsolationCut::kOnlyCharged,thresType,kTRUE), n++); // Ghost multi isolation
 200     }
 201   }
 202
 203   if(kQA)  maker->AddAnalysis(ConfigureQAAnalysis(),n++);
 204
 205   maker->SetAnaDebug(kDebug)  ;
 206   maker->SwitchOnHistogramsMaker()  ;
 207   if(kData.Contains("delta")) maker->SwitchOffAODsMaker() ;
 208   else                        maker->SwitchOnAODsMaker()  ;
 209
 210   if(kPrint) maker->Print("");
 211
 212   printf("<< End Configuration of %d analysis for calorimeter %s >>\n",n, kCalorimeter.Data());
 213
 214   // Create task
 215
 216   AliAnalysisTaskCaloTrackCorrelation * task = new AliAnalysisTaskCaloTrackCorrelation (Form("CaloTrackCorr%s",kName.Data()));
 217   task->SetConfigFileName(""); //Don't configure the analysis via configuration file.
 218   task->SetDebugLevel(kDebug);
 219   task->SetBranches("ESD:AliESDRun.,AliESDHeader");
 220   task->SetAnalysisMaker(maker);
 221   mgr->AddTask(task);
 222
 223   //Create containers
 224
 225   if(outputfile.Length()==0) outputfile = AliAnalysisManager::GetCommonFileName();
 226
 227   AliAnalysisDataContainer *cout_pc   = mgr->CreateContainer(kName, TList::Class(),
 228                                                              AliAnalysisManager::kOutputContainer,
 229                                                              Form("%s",outputfile.Data()));
 230
 231   AliAnalysisDataContainer *cout_cuts = mgr->CreateContainer(Form("Param_%s",kName.Data()), TList::Class(),
 232                                                              AliAnalysisManager::kParamContainer,
 233                                                              "AnalysisParameters.root");
 234
 235   // Create ONLY the output containers for the data produced by the task.
 236   // Get and connect other common input/output containers via the manager as below
 237   //==============================================================================
 238   mgr->ConnectInput  (task, 0, mgr->GetCommonInputContainer());
 239   // AOD output slot will be used in a different way in future
 240   if(!kData.Contains("delta")   && outputAOD) mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
 241   mgr->ConnectOutput (task, 1, cout_pc);
 242   mgr->ConnectOutput (task, 2, cout_cuts);
 243
 244   if(!kMix) task->SelectCollisionCandidates(TriggerMask());
 245
 246   return task;
 247 }
 248
 249 //____________________________________
 250 AliCaloTrackReader * ConfigureReader()
 251 {
 252
 253   AliCaloTrackReader * reader = 0;
 254   if     (kInputDataType == "ESD"&& kData=="MC" )
 255     reader = new AliCaloTrackMCReader();
 256   else if(kInputDataType=="AOD" || kData.Contains("AOD"))
 257     reader = new AliCaloTrackAODReader();
 258   else if(kInputDataType=="ESD")
 259     reader = new AliCaloTrackESDReader();
 260   else
 261     printf("AliCaloTrackReader::ConfigureReader() - Data combination not known kData=%s, kInputData=%s\n",kData.Data(),kInputDataType.Data());
 262
 263   reader->SetDebug(kDebug);//10 for lots of messages
 264
 265   //Delta AOD?
 266   //reader->SetDeltaAODFileName("");
 267   if(kOutputAOD) reader->SwitchOnWriteDeltaAOD()  ;
 268
 269   // MC settings
 270   if(kUseKinematics){
 271     if(kInputDataType == "ESD"){
 272       reader->SwitchOnStack();
 273       reader->SwitchOffAODMCParticles();
 274     }
 275     else if(kInputDataType == "AOD"){
 276       reader->SwitchOffStack();
 277       reader->SwitchOnAODMCParticles();
 278     }
 279   }
 280
 281   //------------------------
 282   // Detector input filling
 283   //------------------------
 284
 285   //Min cluster/track E
 286   reader->SetEMCALEMin(0.3);
 287   reader->SetEMCALEMax(1000);
 288   reader->SetPHOSEMin(0.3);
 289   reader->SetPHOSEMax(1000);
 290   reader->SetCTSPtMin(0.2);
 291   reader->SetCTSPtMax(1000);
 292
 293   if(!kSimulation && kCalibT) reader->SetEMCALTimeCut(-30,30);
 294   else                        reader->SetEMCALTimeCut(-1000,1000); // Open time cut
 295
 296   reader->SwitchOnFiducialCut();
 297   reader->GetFiducialCut()->SetSimpleCTSFiducialCut(0.8, 0, 360) ;
 298
 299   // Tracks
 300   reader->SwitchOnCTS();
 301   if(kInputDataType=="ESD")
 302   {
 303     gROOT->LoadMacro("$ALICE_ROOT/PWGJE/macros/CreateTrackCutsPWGJE.C");
 304     AliESDtrackCuts * esdTrackCuts = CreateTrackCutsPWGJE(10041004);
 305     reader->SetTrackCuts(esdTrackCuts);
 306     reader->SwitchOnConstrainTrackToVertex();
 307   }
 308   else if(kInputDataType=="AOD")
 309   {
 310     reader->SwitchOnAODHybridTrackSelection();
 311     reader->SetTrackFilterMask(128); // Filter bit, not mask, use if off hybrid
 312   }
 313
 314   // Calorimeter
 315
 316   reader->SetEMCALClusterListName(kClusterArray);
 317   if(kClusterArray == "" && !kTender)
 318   {
 319     printf("**************** Standard EMCAL clusters branch analysis **************** \n");
 320     reader->SwitchOnClusterRecalculation();
 321     // Check in ConfigureCaloUtils that the recalibration and bad map are ON
 322   }
 323   else
 324   {
 325     printf("**************** Input for analysis is Clusterizer %s **************** \n", kClusterArray.Data());
 326     reader->SwitchOffClusterRecalculation();
 327   }
 328
 329   //if(kCalorimeter == "EMCAL") {
 330     reader->SwitchOnEMCALCells();
 331     reader->SwitchOnEMCAL();
 332   //}
 333   //if(kCalorimeter == "PHOS") {
 334     reader->SwitchOnPHOSCells();
 335     reader->SwitchOnPHOS();
 336   //}
 337
 338   // for case data="deltaAOD", no need to fill the EMCAL/PHOS cluster lists
 339   if(kData.Contains("delta"))
 340   {
 341     reader->SwitchOffEMCAL();
 342     reader->SwitchOffPHOS();
 343     reader->SwitchOffEMCALCells();
 344     reader->SwitchOffPHOSCells();
 345   }
 346
 347   //-----------------
 348   // Event selection
 349   //-----------------
 350
 351   //if(!kUseKinematics) reader->SetFiredTriggerClassName("CEMC7EGA-B-NOPF-CENTNOTRD"); // L1 Gamma
 352
 353   // For mixing with AliAnaParticleHadronCorrelation switch it off
 354   if(kMix)
 355   {
 356     reader->SwitchOffEventTriggerAtSE();
 357     reader->SetEventTriggerMaks(TriggerMask()); // Only for mixing and SwitchOffEventTriggerAtSE();
 358     reader->SetMixEventTriggerMaks(AliVEvent::kMB); // Careful, not all productions work with kMB, try kINT7, kINT1, kAnyINT
 359
 360     printf("---Trigger selection done in AliCaloTrackReader!!!\n");
 361   }
 362   else
 363     reader->SwitchOnEventTriggerAtSE();
 364   reader->SetZvertexCut(10.);                // Open cut
 365   reader->SwitchOnPrimaryVertexSelection(); // and besides primary vertex
 366
 367   if(kEventSelection)
 368   {
 369     reader->SwitchOnEventSelection();         // remove pileup by default
 370     reader->SwitchOnV0ANDSelection() ;        // and besides v0 AND
 371   }
 372   else
 373   {
 374     reader->SwitchOffEventSelection();         // remove pileup by default
 375     reader->SwitchOffV0ANDSelection() ;        // and besides v0 AND
 376   }
 377
 378   if(kCollisions=="PbPb")
 379   {
 380     // Centrality
 381     reader->SetCentralityClass("V0M");
 382     reader->SetCentralityOpt(10);  // 10 (c= 0-10, 10-20 ...), 20  (c= 0-5, 5-10 ...) or 100 (c= 1, 2, 3 ..)
 383     reader->SetCentralityBin(kMinCen,kMaxCen); // Accept all events, if not select range
 384
 385     // Event plane (only used in Maker and mixing for AliAnaPi0/AliAnaHadronCorrelation for the moment)
 386     reader->SetEventPlaneMethod("V0");
 387   }
 388
 389   if(kYears==2010) reader->SetImportGeometryFromFile(kTRUE,"$ALICE_ROOT/OADB/EMCAL/geometry_2010.root");
 390   else             reader->SetImportGeometryFromFile(kTRUE,"$ALICE_ROOT/OADB/EMCAL/geometry_2011.root");
 391
 392   if(kPrint) reader->Print("");
 393
 394   return reader;
 395
 396 }
 397
 398 //_______________________________________
 399 AliCalorimeterUtils* ConfigureCaloUtils()
 400 {
 401
 402   AliCalorimeterUtils *cu = new AliCalorimeterUtils;
 403   cu->SetDebug(kDebug);
 404
 405   // Remove clusters close to borders, at least max energy cell is 1 cell away
 406   cu->SetNumberOfCellsFromEMCALBorder(1);
 407   cu->SetNumberOfCellsFromPHOSBorder(2);
 408
 409   // Search of local maxima in cluster
 410   if(kCollisions=="pp")
 411   {
 412     cu->SetLocalMaximaCutE(0.1);
 413     cu->SetLocalMaximaCutEDiff(0.03);
 414   }
 415   else
 416   {
 417     cu->SetLocalMaximaCutE(0.2);
 418     cu->SetLocalMaximaCutEDiff(0.03);
 419   }
 420
 421   cu->SwitchOffClusterPlot();
 422
 423   if(kRecalTM) cu->SwitchOnRecalculateClusterTrackMatching(); // Done in clusterization
 424   else         cu->SwitchOffRecalculateClusterTrackMatching();
 425
 426   cu->SwitchOnBadChannelsRemoval() ;
 427
 428   //EMCAL settings
 429
 430   if(!kSimulation)
 431     cu->SwitchOnLoadOwnEMCALGeometryMatrices();
 432
 433   AliEMCALRecoUtils * recou = cu->GetEMCALRecoUtils();
 434
 435
 436   cu->SwitchOnRecalibration(); // Check the reader if it is taken into account during filtering
 437   cu->SwitchOnRunDepCorrection();
 438
 439   gROOT->LoadMacro("$ALICE_ROOT/PWGGA/EMCALTasks/macros/ConfigureEMCALRecoUtils.C");
 440   ConfigureEMCALRecoUtils(recou,
 441                           kSimulation,
 442                           kExotic,
 443                           kNonLinearity,
 444                           kCalibE,
 445                           kBadMap,
 446                           kCalibT);
 447
 448   if( kNonLinearity )
 449   {
 450     printf("ConfigureCaloUtils() - Apply non linearity to EMCAL\n");
 451     cu->SwitchOnCorrectClusterLinearity();
 452   }
 453
 454   printf("ConfigureCaloUtils() - EMCAL Recalibration ON? %d %d\n",recou->IsRecalibrationOn(), cu->IsRecalibrationOn());
 455   printf("ConfigureCaloUtils() - EMCAL BadMap        ON? %d %d\n",recou->IsBadChannelsRemovalSwitchedOn(), cu->IsBadChannelsRemovalSwitchedOn());
 456
 457
 458   // PHOS
 459   cu->SwitchOffLoadOwnPHOSGeometryMatrices();
 460
 461   if(kPrint) cu->Print("");
 462
 463   return cu;
 464
 465 }
 466
 467 //_____________________________________
 468 AliAnaPhoton* ConfigurePhotonAnalysis()
 469 {
 470
 471   AliAnaPhoton *ana = new AliAnaPhoton();
 472   ana->SetDebug(kDebug); //10 for lots of messages
 473
 474   // cluster selection cuts
 475
 476   ana->SwitchOffFiducialCut();
 477
 478   ana->SetCalorimeter(kCalorimeter);
 479
 480   if(kCalorimeter == "PHOS")
 481   {
 482     ana->SetNCellCut(2);// At least 3 cells
 483     ana->SetMinPt(0.3);
 484     ana->SetMinDistanceToBadChannel(2, 4, 5);
 485     ana->SetTimeCut(-2000,2000); // open cut
 486   }
 487   else
 488   {//EMCAL
 489     ana->SetNCellCut(1);// At least 2 cells
 490     ana->SetMinEnergy(0.3); // avoid mip peak at E = 260 MeV
 491     ana->SetMaxEnergy(1000);
 492     ana->SetTimeCut(-1000,1000); // open cut, usual time window of [425-825] ns if time recalibration is off
 493     // restrict to less than 100 ns when time calibration is on
 494     ana->SetMinDistanceToBadChannel(2, 4, 6);
 495   }
 496
 497   if(kTM)
 498   {
 499     ana->SwitchOnTrackMatchRejection() ;
 500     ana->SwitchOffTMHistoFill() ;
 501   }
 502   else
 503   {
 504     ana->SwitchOffTrackMatchRejection() ;
 505     ana->SwitchOnTMHistoFill() ;
 506   }
 507
 508   //PID cuts (shower shape)
 509   ana->SwitchOnCaloPID(); // do PID selection, unless specified in GetCaloPID, selection not based on bayesian
 510   AliCaloPID* caloPID = ana->GetCaloPID();
 511   //Not used in bayesian
 512
 513   //EMCAL
 514   caloPID->SetEMCALLambda0CutMax(0.27);
 515   caloPID->SetEMCALLambda0CutMin(0.10);
 516
 517   caloPID->SetEMCALDEtaCut(0.025);
 518   caloPID->SetEMCALDPhiCut(0.030);
 519
 520   //PHOS
 521   caloPID->SetPHOSDispersionCut(2.5);
 522   caloPID->SetPHOSRCut(2.);
 523   if(kInputData=="AOD") caloPID->SetPHOSRCut(2000.); // Open cut since dX, dZ not stored
 524
 525   ana->SwitchOffFillShowerShapeHistograms();  // Filled before photon shower shape selection
 526
 527   // Input / output delta AOD settings
 528
 529   if(!kData.Contains("delta"))
 530   {
 531     ana->SetOutputAODName(Form("Photon%s",kName.Data()));
 532     ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
 533     //ana->SetOutputAODClassName("AliAODPWG4Particle"); // use if no correlation done
 534   }
 535   else ana->SetInputAODName(Form("Photon%s",kName.Data()));
 536
 537   //Set Histograms name tag, bins and ranges
 538
 539   ana->AddToHistogramsName(Form("AnaPhoton_TM%d_",kTM));
 540   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 541
 542   // Number of particle type MC histograms
 543   ana->FillNOriginHistograms(20);
 544   ana->FillNPrimaryHistograms(20);
 545
 546   ConfigureMC(ana);
 547
 548   if(kPrint) ana->Print("");
 549
 550   return ana;
 551
 552 }
 553
 554 //________________________________________________________________________________
 555 AliAnaElectron* ConfigureElectronAnalysis()
 556 {
 557
 558   AliAnaElectron *ana = new AliAnaElectron();
 559   ana->SetDebug(kDebug); //10 for lots of messages
 560
 561   if(kCalorimeter == "PHOS")
 562   {
 563     ana->SetNCellCut(2);// At least 2 cells
 564     ana->SetMinPt(0.3);
 565     ana->SetMinDistanceToBadChannel(2, 4, 5);
 566   }
 567   else
 568   {//EMCAL
 569     ana->SetNCellCut(1);// At least 2 cells
 570     ana->SetMinPt(0.5); // no effect minium EMCAL cut.
 571     ana->SetMaxPt(100);
 572     //ana->SetTimeCut(400,900);// Time window of [400-900] ns
 573     ana->SetMinDistanceToBadChannel(2, 4, 6);
 574   }
 575
 576   //Electron selection cuts with tracks
 577   ana->SetEOverP(0.85, 1.2);
 578   // TO DO, find a more suitable way to set this
 579   if(kSimulation)
 580   { // LHC11a
 581     ana->SetdEdxCut(76, 85);
 582   }
 583   else // LHC11c
 584   {
 585     ana->SetdEdxCut(56, 64);
 586   }
 587
 588   ana->SetCalorimeter(kCalorimeter);
 589
 590   ana->SwitchOffCaloPID();
 591   ana->SwitchOffFillShowerShapeHistograms();
 592   ana->SwitchOffFillWeightHistograms()  ;
 593   ana->SwitchOffFiducialCut();
 594
 595   if(!kData.Contains("delta"))
 596   {
 597     ana->SetOutputAODName(Form("Electron%s",kName.Data()));
 598     ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
 599   }
 600   else ana->SetInputAODName(Form("Electron%s",kName.Data()));
 601
 602   //Set Histograms name tag, bins and ranges
 603
 604   ana->AddToHistogramsName(Form("AnaElectron_TM%d_",kTM));
 605   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 606
 607   ConfigureMC(ana);
 608
 609   if(kPrint) ana->Print("");
 610
 611   return ana ;
 612
 613 }
 614
 615 //__________________________________________________________________________________________
 616 AliAnaRandomTrigger* ConfigureRandomTriggerAnalysis(TString detector = "")
 617 {
 618
 619   AliAnaRandomTrigger *ana = new AliAnaRandomTrigger();
 620   ana->SetDebug(kDebug); //10 for lots of messages
 621
 622   if(detector=="") detector = kCalorimeter;
 623   ana->SetDetector(detector);
 624
 625   // selection cuts
 626   ana->SetMinPt(4.);
 627   ana->SetMaxPt(51.);
 628
 629   if     (detector=="EMCAL")
 630   {
 631     ana->SetEtaCut(-0.71,0.71);
 632     ana->SetPhiCut(100*TMath::DegToRad(), 160*TMath::DegToRad());
 633   }
 634   else if(detector=="PHOS")
 635   {
 636     ana->SetEtaCut(-0.13,0.13);
 637     ana->SetPhiCut(260*TMath::DegToRad(), 320*TMath::DegToRad());
 638   }
 639   else if(detector=="CTS")
 640   {
 641     ana->SetEtaCut(-0.9,0.9);
 642     ana->SetPhiCut(0, TMath::TwoPi());
 643   }
 644
 645   // AOD branch
 646   if(!kData.Contains("delta"))
 647   {
 648     ana->SetOutputAODName(Form("RandomTrigger%s%s",detector.Data(),kName.Data()));
 649     ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
 650   }
 651   else
 652     ana->SetInputAODName(Form("RandomTrigger%s%s",detector.Data(),kName.Data()));
 653
 654   printf("Set RandomTrigger%s%s\n",detector.Data(),kName.Data());
 655
 656   //Set Histograms name tag, bins and ranges
 657
 658   ana->AddToHistogramsName(Form("AnaRandomTrigger%s_",detector.Data()));
 659
 660   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 661
 662   if(detector=="CTS")
 663   {
 664     ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ;
 665     ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ;
 666   }
 667
 668   if(kPrint) ana->Print("");
 669
 670   return ana;
 671
 672 }
 673
 674 //__________________________________________________________________________________________
 675 AliAnaInsideClusterInvariantMass* ConfigureInClusterIMAnalysis(Float_t l0min, Float_t l0max)
 676 {
 677   AliAnaInsideClusterInvariantMass *ana = new AliAnaInsideClusterInvariantMass();
 678   ana->SetDebug(kDebug); //10 for lots of messages
 679
 680   // selection cuts
 681
 682   ana->SetMinEnergy(5);
 683   ana->SetMaxEnergy(200.);
 684   ana->SetMinNCells(3);
 685   ana->SetM02Cut(l0min,l0max);
 686   ana->SetCalorimeter(kCalorimeter);
 687
 688   //ana->AddToHistogramsName(Form("AnaInClusterIM_%1.2f_%1.2f_",l0min,l0max));
 689   ana->AddToHistogramsName("AnaInClusterIM_");
 690
 691   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 692
 693   AliCaloPID* caloPID = ana->GetCaloPID();
 694   caloPID->SetEMCALDEtaCut(0.025);
 695   caloPID->SetEMCALDPhiCut(0.030);
 696   caloPID->SetClusterSplittingM02Cut(0,100); // Do the selection in the analysis class and not in the PID method to fill SS histograms
 697
 698   caloPID->SetPi0MassRange(0.10, 0.18);
 699   caloPID->SetEtaMassRange(0.40, 0.60);
 700   caloPID->SetPhotonMassRange(0.00, 0.08);
 701
 702   ConfigureMC(ana);
 703
 704   if(kPrint) ana->Print("");
 705
 706   return ana;
 707
 708 }
 709
 710 //_______________________________________________
 711 AliAnaChargedParticles* ConfigureChargedAnalysis()
 712 {
 713
 714   AliAnaChargedParticles *ana = new AliAnaChargedParticles();
 715   ana->SetDebug(kDebug); //10 for lots of messages
 716
 717   // selection cuts
 718
 719   ana->SetMinPt(0.5);
 720   ana->SwitchOnFiducialCut();
 721   ana->GetFiducialCut()->SetSimpleCTSFiducialCut(0.8, 0, 360) ; //more restrictive cut in reader and after in isolation
 722
 723   // Input / output delta AOD settings
 724
 725   if(!kData.Contains("delta"))
 726   {
 727     ana->SetOutputAODName(Form("Hadron%s",kName.Data()));
 728     ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
 729     //ana->SetOutputAODClassName("AliAODPWG4Particle"); // use if no correlation done
 730   }
 731   else
 732     ana->SetInputAODName(Form("Hadron%s",kName.Data()));
 733   printf("Set Hadron%s\n",kName.Data());
 734   //Set Histograms name tag, bins and ranges
 735
 736   ana->AddToHistogramsName("AnaHadrons_");
 737   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 738
 739   ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ;
 740   ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ;
 741
 742   ConfigureMC(ana);
 743
 744   if(kPrint) ana->Print("");
 745
 746   return ana;
 747
 748 }
 749
 750
 751 //_______________________________
 752 AliAnaPi0* ConfigurePi0Analysis()
 753 {
 754
 755   AliAnaPi0 *ana = new AliAnaPi0();
 756
 757   ana->SetDebug(kDebug);//10 for lots of messages
 758
 759   // Input delta AOD settings
 760   ana->SetInputAODName(Form("Photon%s",kName.Data()));
 761
 762   // Calorimeter settings
 763   ana->SetCalorimeter(kCalorimeter);
 764   if(kCalorimeter=="PHOS") ana->SetNumberOfModules(3); //PHOS first year
 765   else
 766   {
 767     if     (kYears == 2010) ana->SetNumberOfModules( 4); // EMCAL first year
 768     else if(kYears == 2011) ana->SetNumberOfModules(10); // Second year
 769     else                    ana->SetNumberOfModules(12);
 770   }
 771
 772   //settings for pp collision mixing
 773   ana->SwitchOnOwnMix(); //Off when mixing done with general mixing frame
 774
 775   // Cuts
 776   if(kCalorimeter=="EMCAL") ana->SetPairTimeCut(70);
 777
 778   if     (kCollisions=="pp"  )
 779   {
 780     ana->SetNCentrBin(1);
 781     ana->SetNZvertBin(10);
 782     ana->SetNRPBin(1);
 783     ana->SetNMaxEvMix(100);
 784     ana->SwitchOnSMCombinations();
 785   }
 786   else if(kCollisions=="PbPb")
 787   {
 788     ana->SetNCentrBin(10);
 789     ana->SetNZvertBin(10);
 790     ana->SetNRPBin(4);
 791     ana->SetNMaxEvMix(10);
 792     ana->SwitchOffSMCombinations();
 793   }
 794
 795   ana->SwitchOffMultipleCutAnalysis();
 796
 797   //Set Histograms name tag, bins and ranges
 798
 799   ana->AddToHistogramsName(Form("AnaPi0_TM%d_",kTM));
 800   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 801
 802   ConfigureMC(ana);
 803
 804   if(kPrint) ana->Print("");
 805
 806   return ana;
 807
 808 }
 809
 810 //_____________________________________________________
 811 AliAnaPi0EbE* ConfigurePi0EbEAnalysis(TString particle,
 812                                       Int_t analysis)
 813 {
 814
 815   AliAnaPi0EbE *ana = new AliAnaPi0EbE();
 816   ana->SetDebug(kDebug);//10 for lots of messages
 817
 818   ana->SetAnalysisType(analysis);
 819   TString opt = "";
 820   if(analysis==AliAnaPi0EbE::kIMCaloTracks) opt = "Conv";
 821   if(analysis==AliAnaPi0EbE::kSSCalo)       opt = "SS";
 822
 823   ana->SetMinPt(0.5);
 824
 825   if(kCalorimeter=="EMCAL")ana->SetPairTimeCut(15); // More strict than in pi0 inv mass analysis
 826
 827   ana->SetCalorimeter(kCalorimeter);
 828
 829   // Input / output delta AOD settings
 830
 831   ana->SetInputAODName(Form("Photon%s",kName.Data()));
 832   if(!kInputDataType.Contains("delta"))
 833   {
 834     ana->SetOutputAODName(Form("%s%s%s",particle.Data(), opt.Data(), kName.Data()));
 835     ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
 836   }
 837   else
 838     ana->SetInputAODName(Form("%s%s%s",particle.Data(),opt.Data(),kName.Data()));
 839
 840   if(analysis == AliAnaPi0EbE::kIMCaloTracks) ana->SetInputAODGammaConvName("PhotonsCTS");
 841
 842   if(analysis!=AliAnaPi0EbE::kSSCalo)
 843   {
 844     AliNeutralMesonSelection *nms = ana->GetNeutralMesonSelection();
 845     nms->SetParticle(particle);
 846
 847     // Tighten a bit mass cut with respect to default window
 848     if(particle=="Pi0") nms->SetInvMassCutRange(0.120,0.150);
 849     if(particle=="Eta") nms->SetInvMassCutRange(0.520,0.580);
 850
 851     nms->SwitchOnAngleSelection();
 852     nms->KeepNeutralMesonSelectionHistos(kTRUE);
 853     //nms->SetAngleMaxParam(2,0.2);
 854     nms->SetHistoERangeAndNBins(0, 20, 80) ;
 855     //nms->SetHistoIMRangeAndNBins(0, 1, 400);
 856   }
 857   else
 858   { // cluster splitting settings
 859     ana->SetTimeCut(-1000,1000); // Open time cut
 860     AliCaloPID* caloPID = ana->GetCaloPID();
 861     caloPID->SetPi0MassRange(0.10, 0.18);
 862     caloPID->SetEtaMassRange(0.40, 0.60);
 863     caloPID->SetPhotonMassRange(0.00, 0.08);
 864     caloPID->SetClusterSplittingM02Cut(0.5,100); // Do the selection in the analysis class and not in the PID method to fill SS histograms
 865   }
 866
 867   ana->SwitchOffSelectedClusterHistoFill();
 868   ana->SwitchOffFillWeightHistograms();
 869
 870   if(!kTM) ana->SwitchOnTMHistoFill();
 871   else     ana->SwitchOffTMHistoFill();
 872
 873   //Set Histograms name tag, bins and ranges
 874
 875   ana->AddToHistogramsName(Form("Ana%s%sEbE_TM%d_",particle.Data(),opt.Data(),kTM));
 876   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 877
 878   ConfigureMC(ana);
 879
 880   if(kPrint) ana->Print("");
 881
 882   return  ana;
 883
 884 }
 885
 886 //____________________________________________________________________________________________________
 887 AliAnaParticleIsolation* ConfigureIsolationAnalysis(TString particle="Photon",
 888                                                     Int_t  partInCone = AliIsolationCut::kOnlyCharged,
 889                                                     Int_t  thresType  = AliIsolationCut::kSumPtFracIC,
 890                                                     Float_t cone = 0.3,
 891                                                     Float_t pth  = 0.3,
 892                                                     Bool_t multi      = kFALSE)
 893 {
 894
 895   AliAnaParticleIsolation *ana = new AliAnaParticleIsolation();
 896   //ana->SetDebug(kDebug);
 897   ana->SetDebug(kDebug);
 898
 899   ana->SwitchOnFiducialCut();
 900   //Avoid borders of EMCal
 901   if(kCalorimeter=="EMCAL")
 902     ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.6, 86, 174) ;
 903
 904   // Same Eta as EMCal, cut in phi if EMCAL was triggering
 905   if(particle=="Hadron"  || particle.Contains("CTS"))
 906   {
 907    // if(kTrig.Contains("EMC"))
 908    //   ana->GetFiducialCut()->SetSimpleCTSFiducialCut  (0.6, 260, 360) ;
 909    // else
 910       ana->GetFiducialCut()->SetSimpleCTSFiducialCut  (0.6, 0, 360) ;
 911   }
 912
 913   ana->SetMinPt(4);
 914
 915   // Input / output delta AOD settings
 916
 917   ana->SetInputAODName(Form("%s%s",particle.Data(),kName.Data()));
 918   ana->SetAODObjArrayName(Form("IC%s_%s",particle.Data(),kName.Data()));
 919
 920   ana->SetCalorimeter(kCalorimeter);
 921
 922   if(!kTM)  ana->SwitchOnTMHistoFill();
 923   else      ana->SwitchOffTMHistoFill();
 924
 925   ana->SwitchOffSSHistoFill();
 926
 927   //Do settings for main isolation cut class
 928   AliIsolationCut * ic =  ana->GetIsolationCut();
 929   ic->SetDebug(kDebug);
 930
 931   if(cone >0 && pth > 0)
 932   {
 933     ic->SetPtThreshold(pth);
 934     ic->SetConeSize(cone);
 935   }
 936   else
 937   {
 938     if(kCollisions=="pp")
 939     {
 940       ic->SetPtThreshold(0.5);
 941       ic->SetConeSize(0.4);
 942     }
 943     if(kCollisions=="PbPb")
 944     {
 945       ic->SetPtThreshold(2.);
 946       //ic->SetPtThreshold(1.);
 947       ic->SetConeSize(0.3);
 948     }
 949   }
 950
 951   ic->SetPtFraction(0.1);
 952   ic->SetSumPtThreshold(1.0) ;
 953   ic->SetParticleTypeInCone(partInCone);
 954   ic->SetICMethod(thresType);
 955
 956   //Do or not do isolation with previously produced AODs.
 957   //No effect if use of SwitchOnSeveralIsolation()
 958   ana->SwitchOffReIsolation();
 959
 960   //Multiple IC
 961   if(multi)
 962   {
 963     ic->SetConeSize(1.);    // Take all for first iteration
 964     ic->SetPtThreshold(100);// Take all for first iteration
 965     ana->SwitchOnSeveralIsolation() ;
 966     ana->SetAODObjArrayName(Form("MultiIC%sTM%d",particle.Data(),kTM));
 967
 968     ana->SetNCones(4);
 969     ana->SetNPtThresFrac(4);
 970     ana->SetConeSizes(0,0.3);       ana->SetConeSizes(1,0.4);
 971     ana->SetConeSizes(2,0.5);       ana->SetConeSizes(3,0.6);
 972     ana->SetPtThresholds(0, 0.5);   ana->SetPtThresholds(1, 1);     ana->SetPtThresholds(2, 2);
 973     ana->SetPtFractions (0, 0.05) ; ana->SetPtFractions (1, 0.1);   ana->SetPtFractions (2, 0.2) ;  ana->SetPtFractions (3, 0.3) ;
 974     ana->SetSumPtThresholds(0, 1) ; ana->SetSumPtThresholds(1, 3) ; ana->SetSumPtThresholds(2, 5);  ana->SetSumPtThresholds(3, 7)  ;
 975
 976     ana->SwitchOffTMHistoFill();
 977     ana->SwitchOffSSHistoFill();
 978   }
 979   else
 980     ana->SwitchOffSeveralIsolation() ;
 981
 982   AliCaloPID* caloPID = ana->GetCaloPID();
 983   caloPID->SetEMCALDEtaCut(0.025);
 984   caloPID->SetEMCALDPhiCut(0.030);
 985
 986   //Set Histograms name tag, bins and ranges
 987
 988   if(!multi)ana->AddToHistogramsName(Form("AnaIsol%s_TM%d_",particle.Data(),kTM));
 989   else      ana->AddToHistogramsName(Form("AnaMultiIsol%s_TM%d_",particle.Data(),kTM));
 990
 991   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 992
 993   ana->SetHistoPtInConeRangeAndNBins(0, 50 , 250);
 994   ana->SetHistoPtSumRangeAndNBins   (0, 100, 250);
 995
 996   if(particle=="Hadron"  || particle.Contains("CTS"))
 997   {
 998     ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ;
 999     ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ;
1000   }
1001
1002   ConfigureMC(ana);
1003
1004   if(kPrint) ic ->Print("");
1005   if(kPrint) ana->Print("");
1006
1007   return ana;
1008
1009 }
1010
1011 //___________________________________________________________________________________
1012 AliAnaParticleHadronCorrelation* ConfigureHadronCorrelationAnalysis(TString particle,
1013                                                                     Int_t bIsolated,
1014                                                                     Int_t  partInCone = AliIsolationCut::kOnlyCharged,
1015                                                                     Int_t  thresType  = AliIsolationCut::kSumPtFracIC,
1016                                                                     Float_t cone = 0.3,
1017                                                                     Float_t pth  = 0.3)
1018 {
1019
1020   AliAnaParticleHadronCorrelation *ana = new AliAnaParticleHadronCorrelation();
1021   ana->SetDebug(kDebug);
1022
1023   ana->SetMinimumTriggerPt(4);
1024   ana->SetAssociatedPtRange(0.2,200);
1025   ana->SetDeltaPhiCutRange( TMath::Pi()/2,3*TMath::Pi()/2 ); //[90 deg, 270 deg]
1026
1027   ana->SetNAssocPtBins(9);
1028
1029   ana->SetAssocPtBinLimit(0, 0.2) ;
1030   ana->SetAssocPtBinLimit(1, 0.5) ;
1031   ana->SetAssocPtBinLimit(2, 1)   ;
1032   ana->SetAssocPtBinLimit(3, 2)   ;
1033   ana->SetAssocPtBinLimit(4, 3)   ;
1034   ana->SetAssocPtBinLimit(5, 4)   ;
1035   ana->SetAssocPtBinLimit(6, 6)   ;
1036   ana->SetAssocPtBinLimit(7, 10)  ;
1037   ana->SetAssocPtBinLimit(8, 30)  ;
1038   ana->SetAssocPtBinLimit(9, 200) ;
1039
1040   ana->SelectIsolated(bIsolated); // do correlation with isolated photons
1041
1042   if(bIsolated)
1043   {
1044     //Do settings for main isolation cut class
1045     AliIsolationCut * ic =  ana->GetIsolationCut();
1046     ic->SetDebug(kDebug);
1047
1048     if(cone >0 && pth > 0)
1049     {
1050       ic->SetPtThreshold(pth);
1051       ic->SetConeSize(cone);
1052     }
1053     else
1054     {
1055       if(kCollisions=="pp")
1056       {
1057         ic->SetPtThreshold(0.5);
1058         ic->SetConeSize(0.4);
1059       }
1060       if(kCollisions=="PbPb")
1061       {
1062         ic->SetPtThreshold(2.);
1063         //ic->SetPtThreshold(1.);
1064         ic->SetConeSize(0.3);
1065       }
1066     }
1067
1068     ic->SetPtFraction(0.1);
1069     ic->SetSumPtThreshold(1.0) ;
1070     ic->SetParticleTypeInCone(partInCone);
1071     ic->SetICMethod(thresType);
1072
1073   }
1074
1075   ana->SwitchOnAbsoluteLeading();  // Select trigger leading particle of all the selected tracks
1076   ana->SwitchOffNearSideLeading(); // Select trigger leading particle of all the particles at +-90 degrees, default
1077
1078   // Mixing with own pool
1079   if(kMix)ana->SwitchOnOwnMix();
1080   else    ana->SwitchOffOwnMix();
1081
1082   ana->SetNZvertBin(4);
1083
1084   if(kCollisions=="pp")
1085   {
1086     ana->SetNMaxEvMix(10);
1087     ana->SwitchOnTrackMultBins();
1088     ana->SetNCentrBin(9); // Fixed track mult values
1089     ana->SetNRPBin(1);
1090   }
1091   else
1092   {
1093     ana->SetNMaxEvMix(5);
1094     ana->SwitchOffTrackMultBins(); // centrality bins
1095     ana->SetNCentrBin(3);
1096     ana->SetNRPBin(3);
1097   }
1098
1099   ana->SwitchOnFiducialCut();
1100
1101   //Avoid borders of EMCal, same as for isolation
1102   if(kCalorimeter=="EMCAL")
1103     ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.6, 86, 174) ;
1104
1105   // Same Eta as EMCal, cut in phi if EMCAL was triggering
1106   if(particle=="Hadron" || particle.Contains("CTS"))
1107   {
1108     //if(kTrig.Contains("EMC"))
1109     //  ana->GetFiducialCut()->SetSimpleCTSFiducialCut  (0.6, 260, 360) ;
1110     //else
1111       ana->GetFiducialCut()->SetSimpleCTSFiducialCut  (0.6, 0, 360) ;
1112   }
1113
1114   // Input / output delta AOD settings
1115
1116   ana->SetInputAODName(Form("%s%s",particle.Data(),kName.Data()));
1117   ana->SetAODObjArrayName(Form("%sHadronCorrIso%d_%s",particle.Data(),bIsolated,kName.Data()));
1118
1119   // Fill extra plots on tagged decay photons
1120   // If trigger is pi0/eta found with invariant mass, get the decays
1121   // If trigger is photon, check if it was tagged as decay previously
1122   if(particle!="Hadron" )
1123   {
1124     if(particle=="Pi0" || particle =="Eta")
1125     {
1126       if(!particle.Contains("SS")) ana->SwitchOnPi0TriggerDecayCorr();
1127       else                         ana->SwitchOffPi0TriggerDecayCorr();
1128       ana->SwitchOffDecayTriggerDecayCorr();
1129     }
1130     else
1131     {
1132       ana->SwitchOffPi0TriggerDecayCorr();
1133       ana->SwitchOnDecayTriggerDecayCorr(); // Make sure pi0 decay tagging runs before this task
1134     }
1135   }
1136   else
1137   {
1138     ana->SwitchOffPi0TriggerDecayCorr();
1139     ana->SwitchOffDecayTriggerDecayCorr();
1140   }
1141
1142   if(particle=="Photon")
1143   {
1144     printf("**** SET M02 limits *** \n");
1145     ana->SetM02Cut(0.15,0.3);
1146   }
1147
1148   // if triggering on PHOS and EMCAL is on
1149   //if(kCalorimeter=="PHOS") ana->SwitchOnNeutralCorr();
1150   ana->SwitchOffNeutralCorr(); // Do only correlation with TPC
1151
1152   ana->SwitchOffHMPIDCorrelation();
1153
1154   ana->SwitchOffFillBradHistograms();
1155
1156   // Underlying event
1157   ana->SwitchOffEventSelection();
1158   ana->SwitchOnSeveralUECalculation();
1159   ana->SetUeDeltaPhiCutRange(TMath::Pi()/3, 2*TMath::Pi()/3);
1160   ana->SetMultiBin(1);
1161
1162   //Set Histograms name tag, bins and ranges
1163
1164   ana->AddToHistogramsName(Form("Ana%sHadronCorr_Iso%d_TM%d_",particle.Data(),bIsolated,kTM));
1165   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
1166
1167   if(particle=="Hadron"  || particle.Contains("CTS"))
1168   {
1169     ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ;
1170     ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ;
1171   }
1172
1173   ConfigureMC(ana);
1174
1175   if(kPrint) ana->Print("");
1176
1177   return ana;
1178
1179 }
1180
1181 //________________________________________
1182 AliAnaCalorimeterQA* ConfigureQAAnalysis()
1183 {
1184
1185   AliAnaCalorimeterQA *ana = new AliAnaCalorimeterQA();
1186   ana->SetDebug(kDebug); //10 for lots of messages
1187   ana->SetCalorimeter(kCalorimeter);
1188
1189   ana->SetTimeCut(-1000,1000); // Open time cut
1190
1191   // Study inter detector correlation (PHOS, EMCAL, Tracks, V0)
1192   if(kCalorimeter=="PHOS"  && kTrig=="PHOS")
1193     ana->SwitchOnCorrelation(); // make sure you switch in the reader PHOS and EMCAL cells and clusters if option is ON
1194   if(kCalorimeter=="EMCAL" && kClusterArray=="")
1195     ana->SwitchOnCorrelation(); // make sure you switch in the reader PHOS and EMCAL cells and clusters if option is ON
1196   else
1197     ana->SwitchOffCorrelation();
1198
1199   // Study exotic clusters PHOS and EMCAL
1200   if(kClusterArray=="") ana->SwitchOnStudyBadClusters() ;
1201   else                  ana->SwitchOffStudyBadClusters() ;
1202
1203
1204   ana->SwitchOffFiducialCut();
1205   ana->SwitchOffFillAllTH3Histogram();
1206   ana->SwitchOffFillAllPositionHistogram();
1207   ana->SwitchOffFillAllPositionHistogram2();
1208   if(!kExotic)ana->SwitchOnStudyBadClusters();
1209   else        ana->SwitchOffStudyBadClusters();
1210   ana->SwitchOffStudyClustersAsymmetry();
1211   ana->SwitchOffStudyWeight();
1212   ana->SwitchOnFillAllTrackMatchingHistogram();
1213   ana->SwitchOffFillAllCellTimeHisto() ;
1214
1215   if(kCalorimeter=="EMCAL")
1216   {
1217     if     (kYears==2010)  ana->SetNumberOfModules(4);
1218     else if(kYears==2011)  ana->SetNumberOfModules(10);
1219     else                   ana->SetNumberOfModules(12);
1220   }
1221   else
1222   {//PHOS
1223     ana->SetNumberOfModules(3);
1224   }
1225
1226   ana->AddToHistogramsName("QA_"); //Begining of histograms name
1227   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
1228
1229   ConfigureMC(ana);
1230
1231   if(kPrint) ana->Print("");
1232
1233   return ana;
1234
1235 }
1236
1237 //________________________________________________________
1238 void ConfigureMC(AliAnaCaloTrackCorrBaseClass* ana)
1239 {
1240   if(kSimulation) ana->SwitchOnDataMC() ;//Access MC stack and fill more histograms, AOD MC not implemented yet.
1241   else            ana->SwitchOffDataMC() ;
1242
1243   //Set here generator name, default pythia
1244   //ana->GetMCAnalysisUtils()->SetMCGenerator("");
1245 }
1246
1247 //________________________________________________________
1248 void SetHistoRangeAndNBins (AliHistogramRanges* histoRanges)
1249 {
1250   // Set common bins for all analysis and MC histograms filling
1251
1252   histoRanges->SetHistoPtRangeAndNBins(0, 100, 200) ; // Energy and pt histograms
1253
1254   if(kCalorimeter=="EMCAL")
1255   {
1256     if(kYears==2010)
1257     {
1258       histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 122*TMath::DegToRad(), 78) ;
1259       histoRanges->SetHistoXRangeAndNBins(-230,90,120); // QA
1260       histoRanges->SetHistoYRangeAndNBins(370,450,40);  // QA
1261     }
1262     else if(kYears==2011)
1263     {
1264       histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 182*TMath::DegToRad(), 108) ;
1265       histoRanges->SetHistoXRangeAndNBins(-600,90,200); // QA
1266       histoRanges->SetHistoYRangeAndNBins(100,450,100); // QA
1267     }
1268     else
1269     {
1270       histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 190*TMath::DegToRad(), 122) ;
1271       histoRanges->SetHistoXRangeAndNBins(-100,90,200); // QA
1272       histoRanges->SetHistoYRangeAndNBins(50,450,100);  // QA
1273     }
1274
1275     histoRanges->SetHistoEtaRangeAndNBins(-0.72, 0.72, 144) ;
1276   }
1277   else
1278   {
1279     histoRanges->SetHistoPhiRangeAndNBins(260*TMath::DegToRad(), 320*TMath::DegToRad(), 60) ;
1280     histoRanges->SetHistoEtaRangeAndNBins(-0.13, 0.13, 130) ;
1281   }
1282
1283   histoRanges->SetHistoShowerShapeRangeAndNBins(-0.1, 4.9, 500);
1284
1285   // Invariant mass histoRangeslysis
1286   histoRanges->SetHistoMassRangeAndNBins(0., 1., 200) ;
1287   histoRanges->SetHistoAsymmetryRangeAndNBins(0., 1. , 100) ;
1288
1289   // check if time calibration is on
1290   histoRanges->SetHistoTimeRangeAndNBins(-1000.,1000,1000);
1291   histoRanges->SetHistoDiffTimeRangeAndNBins(-200, 200, 800);
1292
1293   // track-cluster residuals
1294   histoRanges->SetHistoTrackResidualEtaRangeAndNBins(-0.15,0.15,300);
1295   histoRanges->SetHistoTrackResidualPhiRangeAndNBins(-0.15,0.15,300);
1296   histoRanges->SetHistodRRangeAndNBins(0.,0.15,150);//QA
1297
1298   // QA, electron, charged
1299   histoRanges->SetHistoPOverERangeAndNBins(0,10.,100);
1300   histoRanges->SetHistodEdxRangeAndNBins(0.,200.,200);
1301
1302   // QA
1303   histoRanges->SetHistoFinePtRangeAndNBins(0, 10, 200) ; // bining for fhAmpId
1304   histoRanges->SetHistoRatioRangeAndNBins(0.,2.,100);
1305   histoRanges->SetHistoVertexDistRangeAndNBins(0.,500.,500);
1306   histoRanges->SetHistoNClusterCellRangeAndNBins(0,500,500);
1307   histoRanges->SetHistoZRangeAndNBins(-400,400,200);
1308   histoRanges->SetHistoRRangeAndNBins(400,450,25);
1309   histoRanges->SetHistoV0SignalRangeAndNBins(0,5000,500);
1310   histoRanges->SetHistoV0MultiplicityRangeAndNBins(0,5000,500);
1311   histoRanges->SetHistoTrackMultiplicityRangeAndNBins(0,5000,500);
1312
1313 }
1314
1315 //_________________
1316 Int_t TriggerMask()
1317 {
1318   if(kTrig=="EMC7")
1319   {
1320     printf("CaloTrackCorr trigger EMC7\n");
1321     return AliVEvent::kEMC7;
1322   }
1323   else if (kTrig=="INT7")
1324   {
1325     printf("CaloTrackCorr trigger INT7\n");
1326     return AliVEvent::kINT7;
1327   }
1328   else if(kTrig=="EMC1")
1329   {
1330     printf("CaloTrackCorr trigger EMC1\n");
1331     return AliVEvent::kEMC1;
1332   }
1333   else if(kTrig=="MB")
1334   {
1335     printf("CaloTrackCorr trigger MB\n");
1336     return AliVEvent::kMB;
1337   }
1338   else if(kTrig=="PHOS")
1339   {
1340     printf("CaloTrackCorr trigger PHOS\n");
1341     return AliVEvent::kPHI7;
1342   }
1343   else if(kTrig=="PHOSPb")
1344   {
1345     printf("CaloTrackCorr trigger PHOSPb\n");
1346     return AliVEvent::kPHOSPb;
1347   }
1348   else if(kTrig=="AnyINT")
1349   {
1350     printf("CaloTrackCorr trigger AnyINT\n");
1351     return AliVEvent::kAnyINT;
1352   }
1353   else if(kTrig=="INT")
1354   {
1355     printf("CaloTrackCorr trigger AnyINT\n");
1356     return AliVEvent::kAny;
1357   }
1358   else if(kTrig=="EMCEGA")
1359   {
1360     printf("CaloTrackCorr trigger EMC Gamma\n");
1361     return AliVEvent::kEMCEGA;
1362   }
1363   else if(kTrig=="EMCEJE")
1364   {
1365     printf("CaloTrackCorr trigger EMC Jet\n");
1366     return AliVEvent::kEMCEJE;
1367   }
1368   else if(kTrig=="Central")
1369   {
1370     printf("CaloTrackCorr trigger Central\n");
1371     return AliVEvent::kCentral;
1372   }
1373   else if(kTrig=="SemiCentral")
1374   {
1375     printf("CaloTrackCorr trigger SemiCentral\n");
1376     return AliVEvent::kSemiCentral;
1377   }
1378   else if(kTrig=="SemiOrCentral")
1379   {
1380     printf("CaloTrackCorr trigger SemiCentral Or Central\n");
1381     return (AliVEvent::kSemiCentral | AliVEvent::kCentral);
1382   }
1383 }
1384