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