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 Int_t   kRunNumber     = -1;
  30
  31 AliAnalysisTaskCaloTrackCorrelation *AddTaskCaloTrackCorr(const TString  data          = "",
  32                                                           const TString  calorimeter   = "EMCAL",
  33                                                           const Bool_t   simulation    = kFALSE,
  34                                                           const Bool_t   eventsel      = kFALSE,
  35                                                           const Bool_t   exotic        = kTRUE,
  36                                                           const Bool_t   nonlin        = kFALSE,
  37                                                           TString        outputfile    = "",
  38                                                           const Int_t    year          = 2010,
  39                                                           const TString  col           = "pp",
  40                                                           const TString  trigger       = "MB",
  41                                                           const TString  clustersArray = "V1",
  42                                                           const Bool_t   mix           = kTRUE,
  43                                                           const Bool_t   recaltm       = kTRUE,
  44                                                           const Bool_t   tm            = kTRUE,
  45                                                           const Int_t    minCen        = -1,
  46                                                           const Int_t    maxCen        = -1,
  47                                                           const Bool_t   qaan          = kFALSE,
  48                                                           const Bool_t   hadronan      = kFALSE,
  49                                                           const Bool_t   calibE        = kTRUE,
  50                                                           const Bool_t   badmap        = kTRUE,
  51                                                           const Bool_t   calibT        = kTRUE,
  52                                                           const Bool_t   tender        = kFALSE,
  53                                                           const Bool_t   outputAOD     = kFALSE,
  54                                                           const Bool_t   printSettings = kFALSE,
  55                                                           const Double_t scaleFactor   = -1,
  56                                                           const Int_t    runNumber     = -1
  57                                                           )
  58 {
  59   // Creates a CaloTrackCorr task, configures it and adds it to the analysis manager.
  60
  61   kPrint         = printSettings;
  62   kSimulation    = simulation;
  63   kYears         = year;
  64   kCollisions    = col;
  65   kExotic        = exotic;
  66   kNonLinearity  = nonlin;
  67   kTrig          = trigger;
  68   kClusterArray  = clustersArray;
  69   kData          = data;
  70   kCalorimeter   = calorimeter;
  71   kOutputAOD     = outputAOD;
  72   kTM            = tm;
  73   kRecalTM       = recaltm;
  74   kMinCen        = minCen;
  75   kMaxCen        = maxCen;
  76   kEventSelection= eventsel;
  77   kQA            = qaan;
  78   kHadronAN      = hadronan;
  79   kCalibE        = calibE;
  80   kCalibT        = calibT;
  81   kBadMap        = badmap;
  82   kTender        = tender;
  83   kMix           = mix;
  84   kRunNumber     = runNumber;
  85
  86   // Get the pointer to the existing analysis manager via the static access method.
  87
  88   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  89   if (!mgr)
  90   {
  91     ::Error("AddTask", "No analysis manager to connect to.");
  92     return NULL;
  93   }
  94
  95   // Check the analysis type using the event handlers connected to the analysis manager.
  96
  97   if (!mgr->GetInputEventHandler())
  98   {
  99     ::Error("AddTask", "This task requires an input event handler");
 100     return NULL;
 101   }
 102
 103   // Make sure the B field is enabled for track selection, some cuts need it
 104   ((AliInputEventHandler*)mgr->GetInputEventHandler())->SetNeedField(kTRUE);
 105
 106   kInputDataType = "AOD";
 107   if(!kData.Contains("delta"))
 108     kInputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
 109
 110   if(kSimulation)
 111   {
 112     kUseKinematics = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
 113     if (!kUseKinematics && data=="AOD" && kInputDataType != "ESD") kUseKinematics = kTRUE; //AOD primary should be available ...
 114   }
 115
 116   cout<<"********* ACCESS KINE? "<<kUseKinematics<<endl;
 117
 118   // Name for containers
 119
 120   kName = Form("%s_Trig%s_Cl%s_TM%d",kCalorimeter.Data(), kTrig.Data(),kClusterArray.Data(),kTM);
 121
 122   if(kCollisions=="PbPb" && kMaxCen>=0) kName+=Form("Cen%d_%d",kMinCen,kMaxCen);
 123
 124   printf("<<<< NAME: %s >>>>>\n",kName.Data());
 125
 126   // #### Configure analysis ####
 127
 128   AliAnaCaloTrackCorrMaker * maker = new AliAnaCaloTrackCorrMaker();
 129
 130   maker->SetScaleFactor(scaleFactor); // for MC, negative (not scaled) by default
 131
 132   // General frame setting and configuration
 133   maker->SetReader   (ConfigureReader()   );
 134   maker->SetCaloUtils(ConfigureCaloUtils());
 135
 136   // Analysis tasks setting and configuration
 137   Int_t n = 0;//Analysis number, order is important
 138
 139   // Isolation settings
 140   Int_t partInCone = AliIsolationCut::kNeutralAndCharged; // kOnlyCharged;
 141   Int_t thresType  = AliIsolationCut::kPtThresIC;//  AliIsolationCut::kSumPtFracIC ;
 142   Float_t cone = -1;
 143   Float_t pth  = -1;
 144
 145   // Photon analysis
 146
 147   maker->AddAnalysis(ConfigurePhotonAnalysis(), n++); // Photon cluster selection
 148
 149   // Invariant mass analysis Put here to tag selected photons as decay
 150   maker->AddAnalysis(ConfigurePi0EbEAnalysis("Pi0", AliAnaPi0EbE::kIMCalo), n++); // Pi0 event by event selection, invariant mass and photon tagging from decay
 151   maker->AddAnalysis(ConfigurePi0EbEAnalysis("Eta", AliAnaPi0EbE::kIMCalo), n++); // Eta event by event selection, invariant mass and photon tagging from decay
 152
 153   // Photon analysis
 154   maker->AddAnalysis(ConfigureIsolationAnalysis("Photon", partInCone,thresType,cone, pth), n++); // Photon isolation
 155   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Photon",kFALSE), n++); // Gamma hadron correlation
 156   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Photon",kTRUE,partInCone,thresType, cone, pth) , n++); // Isolated gamma hadron correlation
 157   //maker->AddAnalysis(ConfigureIsolationAnalysis("Photon", partInCone,thresType,kTRUE), n++); // Photon multi isolation, leave it the last
 158
 159
 160   // Split cluster analysis
 161   if(kCalorimeter == "EMCAL")
 162   {
 163     maker->AddAnalysis(ConfigurePi0EbEAnalysis("Pi0", AliAnaPi0EbE::kSSCalo), n++); // Pi0 event by event selection, cluster splitting
 164     maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0SS", partInCone,thresType,cone, pth), n++);       // Pi0 isolation, cluster splits
 165     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SS" ,kFALSE), n++); // Pi0 hadron correlation
 166     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SS" ,kTRUE,partInCone,thresType, cone, pth) , n++); // Isolated pi0 hadron correlation
 167     //maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0SS",  partInCone,thresType,kTRUE), n++); // Pi0 multi isolation, split cluster
 168     maker->AddAnalysis(ConfigureInClusterIMAnalysis(kTRUE , kTRUE ), n++);
 169   }
 170
 171   // Invariant mass analysis
 172   maker->AddAnalysis(ConfigurePi0EbEAnalysis("Pi0SideBand", AliAnaPi0EbE::kIMCalo), n++); // Pi0 event by event selection, and photon tagging from decay
 173   maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0", partInCone,thresType,cone, pth), n++);         // Pi0 isolation, invariant mass
 174   maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0SideBand", partInCone,thresType,cone, pth), n++); // Pi0 isolation, side band
 175   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0"   ,kFALSE), n++); // Pi0 hadron correlation
 176   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0"   ,kTRUE,partInCone,thresType, cone, pth) , n++); // Isolated pi0 hadron correlation
 177   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SideBand" ,kFALSE), n++); // Pi0 hadron correlation
 178   maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Pi0SideBand" ,kTRUE,partInCone,thresType, cone, pth) , n++); // Isolated pi0 hadron correlation
 179   //maker->AddAnalysis(ConfigureIsolationAnalysis("Pi0",    partInCone,thresType,kTRUE), n++); // Pi0 multi isolation, invariant mass, leave it the last
 180
 181   if(kHadronAN)
 182   {
 183     maker->AddAnalysis(ConfigureChargedAnalysis(), n++);                                // track selection
 184     maker->AddAnalysis(ConfigureIsolationAnalysis("Hadron",AliIsolationCut::kOnlyCharged,thresType,cone, pth), n++); // track isolation
 185     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Hadron",kFALSE), n++);       // track-track correlation
 186     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("Hadron",kTRUE,partInCone,thresType, cone, pth) , n++);       // Isolated track-track correlation
 187     //maker->AddAnalysis(ConfigureIsolationAnalysis("Hadron",partInCone,thresType,kTRUE), n++);// Hadron multi isolation
 188   }
 189
 190   // Analysis with ghost triggers, only for Min Bias like events
 191   if( kTrig.Contains("INT") || kTrig.Contains("Central") || kTrig.Contains("MB")  )
 192   {
 193     maker->AddAnalysis(ConfigureRandomTriggerAnalysis(), n++);
 194     maker->AddAnalysis(ConfigureIsolationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()), partInCone,thresType,cone, pth), n++); // Ghost trigger isolation
 195     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()),kFALSE), n++); // Ghost trigger hadron correlation
 196     maker->AddAnalysis(ConfigureHadronCorrelationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()),kTRUE,partInCone,thresType, cone, pth) , n++); // Isolated ghost hadron correlation
 197     //maker->AddAnalysis(ConfigureIsolationAnalysis(Form("RandomTrigger%s",kCalorimeter.Data()), partInCone,thresType,kTRUE), n++); // Ghost multi isolation
 198
 199     if(kHadronAN)
 200     {
 201       maker->AddAnalysis(ConfigureRandomTriggerAnalysis("CTS"), n++);                                // track selection
 202       maker->AddAnalysis(ConfigureIsolationAnalysis("RandomTriggerCTS",AliIsolationCut::kOnlyCharged,thresType,cone, pth), n++); // track isolation
 203       maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("RandomTriggerCTS",kFALSE), n++);       // track-track correlation
 204       maker->AddAnalysis(ConfigureHadronCorrelationAnalysis("RandomTriggerCTS",kTRUE,partInCone,thresType, cone, pth) , n++);       // Isolated track-track correlation
 205       //maker->AddAnalysis(ConfigureIsolationAnalysis("RandomTriggerCTS",AliIsolationCut::kOnlyCharged,thresType,kTRUE), n++); // Ghost multi isolation
 206     }
 207   }
 208
 209   if(kQA)  maker->AddAnalysis(ConfigureQAAnalysis(),n++);
 210
 211   maker->SetAnaDebug(kDebug)  ;
 212   maker->SwitchOnHistogramsMaker()  ;
 213   if(kData.Contains("delta")) maker->SwitchOffAODsMaker() ;
 214   else                        maker->SwitchOnAODsMaker()  ;
 215
 216   if(kPrint) maker->Print("");
 217
 218   if(kSimulation) maker->SwitchOffDataControlHistograms();
 219
 220   printf("<< End Configuration of %d analysis for calorimeter %s >>\n",n, kCalorimeter.Data());
 221
 222   // Create task
 223
 224   AliAnalysisTaskCaloTrackCorrelation * task = new AliAnalysisTaskCaloTrackCorrelation (Form("CaloTrackCorr%s",kName.Data()));
 225   task->SetConfigFileName(""); //Don't configure the analysis via configuration file.
 226   task->SetDebugLevel(kDebug);
 227   task->SetBranches("ESD:AliESDRun.,AliESDHeader");
 228   task->SetAnalysisMaker(maker);
 229   mgr->AddTask(task);
 230
 231   //Create containers
 232
 233   if(outputfile.Length()==0) outputfile = AliAnalysisManager::GetCommonFileName();
 234
 235   AliAnalysisDataContainer *cout_pc   = mgr->CreateContainer(kName, TList::Class(),
 236                                                              AliAnalysisManager::kOutputContainer,
 237                                                              Form("%s",outputfile.Data()));
 238
 239   AliAnalysisDataContainer *cout_cuts = mgr->CreateContainer(Form("Param_%s",kName.Data()), TList::Class(),
 240                                                              AliAnalysisManager::kParamContainer,
 241                                                              "AnalysisParameters.root");
 242
 243   // Create ONLY the output containers for the data produced by the task.
 244   // Get and connect other common input/output containers via the manager as below
 245   //==============================================================================
 246   mgr->ConnectInput  (task, 0, mgr->GetCommonInputContainer());
 247   // AOD output slot will be used in a different way in future
 248   if(!kData.Contains("delta")   && outputAOD) mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
 249   mgr->ConnectOutput (task, 1, cout_pc);
 250   mgr->ConnectOutput (task, 2, cout_cuts);
 251
 252   if(!kMix)
 253   {
 254     UInt_t mask =  SetTriggerMaskFromName();
 255     task->SelectCollisionCandidates(mask);
 256   }
 257
 258   return task;
 259 }
 260
 261 //____________________________________
 262 AliCaloTrackReader * ConfigureReader()
 263 {
 264
 265   AliCaloTrackReader * reader = 0;
 266   if     (kInputDataType == "ESD"&& kData=="MC" )
 267     reader = new AliCaloTrackMCReader();
 268   else if(kInputDataType=="AOD" || kData.Contains("AOD"))
 269     reader = new AliCaloTrackAODReader();
 270   else if(kInputDataType=="ESD")
 271     reader = new AliCaloTrackESDReader();
 272   else
 273     printf("AliCaloTrackReader::ConfigureReader() - Data combination not known kData=%s, kInputData=%s\n",kData.Data(),kInputDataType.Data());
 274
 275   reader->SetDebug(kDebug);//10 for lots of messages
 276
 277   /*
 278    if(kSimulation)
 279    {
 280      // Event rejection cuts for jet-jet simulations
 281      reader->SetPtHardAndJetPtComparison(kTRUE);
 282      reader->SetPtHardAndJetPtFactor(4);
 283
 284      reader->SetPtHardAndClusterPtComparison(kTRUE);
 285      reader->SetPtHardAndClusterPtFactor(1.5);
 286    }
 287    */
 288
 289   //Delta AOD?
 290   //reader->SetDeltaAODFileName("");
 291   if(kOutputAOD) reader->SwitchOnWriteDeltaAOD()  ;
 292
 293   // MC settings
 294   if(kUseKinematics){
 295     if(kInputDataType == "ESD"){
 296       reader->SwitchOnStack();
 297       reader->SwitchOffAODMCParticles();
 298     }
 299     else if(kInputDataType == "AOD"){
 300       reader->SwitchOffStack();
 301       reader->SwitchOnAODMCParticles();
 302     }
 303   }
 304
 305   //------------------------
 306   // Detector input filling
 307   //------------------------
 308
 309   //Min cluster/track E
 310   reader->SetEMCALEMin(0.3);
 311   reader->SetEMCALEMax(1000);
 312   reader->SetPHOSEMin(0.3);
 313   reader->SetPHOSEMax(1000);
 314   reader->SetCTSPtMin(0.2);
 315   reader->SetCTSPtMax(1000);
 316
 317   // Time cuts
 318   if(kSimulation)
 319   {
 320     reader->SwitchOffUseTrackTimeCut();
 321     reader->SwitchOffUseParametrizedTimeCut();
 322     reader->SwitchOffUseEMCALTimeCut();
 323     reader->SetEMCALTimeCut(-1e10,1e10); // Open time cut
 324   }
 325   else
 326   {
 327     if(kCalibT)
 328     {
 329       printf("Set time cut parameters for run %d\n",kRunNumber);
 330       reader->SwitchOnUseEMCALTimeCut();
 331       reader->SwitchOnUseParametrizedTimeCut();
 332
 333       //Absolute window
 334       reader->SetEMCALTimeCut(-25,20);
 335
 336       //Parametrization
 337       if     (kRunNumber >= 151636 && kRunNumber <= 155384 )
 338       {
 339         printf("Set time parameters for LHC11c");
 340         reader->SetEMCALParametrizedMinTimeCut(0,-5  ); reader->SetEMCALParametrizedMinTimeCut(1,-1 ); reader->SetEMCALParametrizedMinTimeCut(2, 1.87); reader->SetEMCALParametrizedMinTimeCut(3, 0.4);
 341         reader->SetEMCALParametrizedMaxTimeCut(0, 3.5); reader->SetEMCALParametrizedMaxTimeCut(1, 50); reader->SetEMCALParametrizedMaxTimeCut(2, 0.15); reader->SetEMCALParametrizedMaxTimeCut(3, 1.6);
 342       }
 343       else if(kRunNumber >= 156447 && kRunNumber <= 159635 )
 344       {
 345         printf("Set time parameters for LHC11d");
 346         reader->SetEMCALParametrizedMinTimeCut(0,-5);  reader->SetEMCALParametrizedMinTimeCut(1,-1 );  reader->SetEMCALParametrizedMinTimeCut(2, 3.5 ); reader->SetEMCALParametrizedMinTimeCut(3, 1.  );
 347         reader->SetEMCALParametrizedMaxTimeCut(0, 5);  reader->SetEMCALParametrizedMaxTimeCut(1, 50);  reader->SetEMCALParametrizedMaxTimeCut(2, 0.45); reader->SetEMCALParametrizedMaxTimeCut(3, 1.25);
 348       }
 349       else
 350       {
 351         reader->SwitchOffUseParametrizedTimeCut();
 352       }
 353     }
 354     else
 355     {
 356       reader->SwitchOffUseParametrizedTimeCut();
 357       reader->SwitchOffUseEMCALTimeCut();
 358       reader->SetEMCALTimeCut(-1e10,1e10); // Open time cut
 359     }
 360   }
 361
 362   reader->SwitchOnFiducialCut();
 363   reader->GetFiducialCut()->SetSimpleCTSFiducialCut(0.8, 0, 360) ;
 364
 365   // Tracks
 366   reader->SwitchOnCTS();
 367   reader->SwitchOffRejectNoTrackEvents();
 368
 369   reader->SwitchOffRecalculateVertexBC();
 370   reader->SwitchOffVertexBCEventSelection();
 371
 372   reader->SwitchOffUseTrackTimeCut();
 373   reader->SetTrackTimeCut(0,50);
 374
 375   reader->SwitchOffUseTrackDCACut();
 376   //reader->SetTrackDCACut(0,0.0105);
 377   //reader->SetTrackDCACut(1,0.035);
 378   //reader->SetTrackDCACut(2,1.1);
 379
 380   if(kInputDataType=="ESD")
 381   {
 382     gROOT->LoadMacro("$ALICE_ROOT/PWGJE/macros/CreateTrackCutsPWGJE.C");
 383     //AliESDtrackCuts * esdTrackCuts = CreateTrackCutsPWGJE(10041004);
 384     //reader->SetTrackCuts(esdTrackCuts);
 385     //reader->SwitchOnConstrainTrackToVertex();
 386
 387     if(kYears>2010)
 388     {
 389       //Hybrids 2011
 390       AliESDtrackCuts * esdTrackCuts  = CreateTrackCutsPWGJE(10001008);
 391       reader->SetTrackCuts(esdTrackCuts);
 392       AliESDtrackCuts * esdTrackCuts2 = CreateTrackCutsPWGJE(10011008);
 393       reader->SetTrackComplementaryCuts(esdTrackCuts2);
 394     }
 395     else
 396     {
 397       //Hybrids 2010
 398       AliESDtrackCuts * esdTrackCuts  = CreateTrackCutsPWGJE(10001006);
 399       reader->SetTrackCuts(esdTrackCuts);
 400       AliESDtrackCuts * esdTrackCuts2 = CreateTrackCutsPWGJE(10041006);
 401       reader->SetTrackComplementaryCuts(esdTrackCuts2);
 402     }
 403   }
 404   else if(kInputDataType=="AOD")
 405   {
 406     //reader->SetTrackFilterMask(128);           // Filter bit, not mask, use if off hybrid
 407     reader->SwitchOnAODHybridTrackSelection(); // Check that the AODs have Hybrids!!!!
 408     reader->SetTrackStatus(AliVTrack::kITSrefit);
 409     //reader->SwitchOnTrackHitSPDSelection();    // Check that the track has at least a hit on the SPD, not much sense to use for hybrid or TPC only tracks
 410   }
 411
 412   // Calorimeter
 413
 414   reader->SetEMCALClusterListName(kClusterArray);
 415   if(kClusterArray == "" && !kTender)
 416   {
 417     printf("**************** Standard EMCAL clusters branch analysis **************** \n");
 418     reader->SwitchOnClusterRecalculation();
 419     // Check in ConfigureCaloUtils that the recalibration and bad map are ON
 420   }
 421   else
 422   {
 423     printf("**************** Input for analysis is Clusterizer %s **************** \n", kClusterArray.Data());
 424     reader->SwitchOffClusterRecalculation();
 425   }
 426
 427   if(!kNonLinearity) reader->SwitchOffClusterELinearityCorrection();
 428
 429   //if(kCalorimeter == "EMCAL") {
 430     reader->SwitchOnEMCALCells();
 431     reader->SwitchOnEMCAL();
 432   //}
 433   //if(kCalorimeter == "PHOS") {
 434     reader->SwitchOnPHOSCells();
 435     reader->SwitchOnPHOS();
 436   //}
 437
 438   // for case data="deltaAOD", no need to fill the EMCAL/PHOS cluster lists
 439   if(kData.Contains("delta"))
 440   {
 441     reader->SwitchOffEMCAL();
 442     reader->SwitchOffPHOS();
 443     reader->SwitchOffEMCALCells();
 444     reader->SwitchOffPHOSCells();
 445   }
 446
 447   //-----------------
 448   // Event selection
 449   //-----------------
 450
 451   //reader->RejectFastClusterEvents()  ;
 452
 453   // Event triggered selection settings
 454   reader->SwitchOnTriggerPatchMatching();
 455   reader->SwitchOnBadTriggerEventsRemoval(); // only if SwitchOnTriggerPatchMatching();
 456   reader->SwitchOnUnMatchedTriggerEventsRemoval(); // only if SwitchOnBadTriggerEventsRemoval();
 457   //reader->SwitchOffTriggerClusterTimeRecal() ;
 458
 459   reader->SetTriggerPatchTimeWindow(8,9); // L0
 460   if     (kRunNumber < 146861) reader->SetEventTriggerL0Threshold(3.);
 461   else if(kRunNumber < 154000) reader->SetEventTriggerL0Threshold(4.);
 462   else if(kRunNumber < 165000) reader->SetEventTriggerL0Threshold(5.5);
 463
 464   //redefine for other periods, triggers
 465
 466   //if(!kUseKinematics) reader->SetFiredTriggerClassName("CEMC7EGA-B-NOPF-CENTNOTRD"); // L1 Gamma
 467
 468   // For mixing with AliAnaParticleHadronCorrelation switch it off
 469   if(kMix)
 470   {
 471     reader->SwitchOffEventTriggerAtSE();
 472     UInt_t mask =  SetTriggerMaskFromName();
 473     reader->SetEventTriggerMask(mask); // Only for mixing and SwitchOffEventTriggerAtSE();
 474     //reader->SetMixEventTriggerMask(AliVEvent::kMB); // Careful, not all productions work with kMB, try kINT7, kINT1, kAnyINT
 475     reader->SetMixEventTriggerMask(AliVEvent::kAnyINT); // Careful, not all productions work with kMB, try kINT7, kINT1, kAnyINT
 476
 477     printf("---Trigger selection done in AliCaloTrackReader!!!\n");
 478   }
 479   else
 480     reader->SwitchOnEventTriggerAtSE();
 481
 482   reader->SetZvertexCut(10.);               // Open cut
 483   reader->SwitchOnPrimaryVertexSelection(); // and besides primary vertex
 484
 485   if(kEventSelection)
 486   {
 487     reader->SwitchOnEventPileUpRejection(); // remove pileup by default
 488     reader->SwitchOnV0ANDSelection() ;      // and besides v0 AND
 489   }
 490   else
 491   {
 492     reader->SwitchOffPileUpEventRejection();// remove pileup by default
 493     reader->SwitchOffV0ANDSelection() ;     // and besides v0 AND
 494   }
 495
 496   if(kCollisions=="PbPb")
 497   {
 498     // Centrality
 499     reader->SetCentralityClass("V0M");
 500     reader->SetCentralityOpt(100);  // 10 (c= 0-10, 10-20 ...), 20  (c= 0-5, 5-10 ...) or 100 (c= 1, 2, 3 ..)
 501     reader->SetCentralityBin(kMinCen,kMaxCen); // Accept all events, if not select range
 502
 503     // Event plane (only used in Maker and mixing for AliAnaPi0/AliAnaHadronCorrelation for the moment)
 504     reader->SetEventPlaneMethod("V0");
 505   }
 506
 507   if(kPrint) reader->Print("");
 508
 509   return reader;
 510
 511 }
 512
 513 //_______________________________________
 514 AliCalorimeterUtils* ConfigureCaloUtils()
 515 {
 516
 517   AliCalorimeterUtils *cu = new AliCalorimeterUtils;
 518   cu->SetDebug(kDebug);
 519
 520   // Remove clusters close to borders, at least max energy cell is 1 cell away
 521   cu->SetNumberOfCellsFromEMCALBorder(1);
 522   cu->SetNumberOfCellsFromPHOSBorder(2);
 523
 524   // Search of local maxima in cluster
 525   if(kCollisions=="pp")
 526   {
 527     cu->SetLocalMaximaCutE(0.1);
 528     cu->SetLocalMaximaCutEDiff(0.03);
 529     if(kName.Contains("150"))
 530     {
 531       printf("Reclusterize with 150 threshold, set PbPb settings\n");
 532       cu->SetLocalMaximaCutE(0.2);
 533       cu->SetLocalMaximaCutEDiff(0.03);
 534     }
 535   }
 536   else
 537   {
 538     cu->SetLocalMaximaCutE(0.2);
 539     cu->SetLocalMaximaCutEDiff(0.03);
 540   }
 541
 542   cu->SwitchOffClusterPlot();
 543
 544   if(kRecalTM) cu->SwitchOnRecalculateClusterTrackMatching(); // Done in clusterization
 545   else         cu->SwitchOffRecalculateClusterTrackMatching();
 546
 547   cu->SwitchOnBadChannelsRemoval() ;
 548
 549   //EMCAL settings
 550
 551   if(!kSimulation)
 552     cu->SwitchOnLoadOwnEMCALGeometryMatrices();
 553
 554   AliEMCALRecoUtils * recou = cu->GetEMCALRecoUtils();
 555
 556   if(!kSimulation)
 557   {
 558     cu->SwitchOnRecalibration(); // Check the reader if it is taken into account during filtering
 559     if(kClusterArray == "" && !kTender) cu->SwitchOnRunDepCorrection();
 560   }
 561
 562   gROOT->LoadMacro("$ALICE_ROOT/PWGGA/EMCALTasks/macros/ConfigureEMCALRecoUtils.C");
 563   ConfigureEMCALRecoUtils(recou,
 564                           kSimulation,
 565                           kExotic,
 566                           kTRUE,//kNonLinearity,
 567                           kCalibE,
 568                           kBadMap,
 569                           kCalibT);
 570   //recou->SetExoticCellDiffTimeCut(50.);
 571
 572
 573   if( kNonLinearity )
 574   {
 575     printf("ConfigureCaloUtils() - Apply non linearity to EMCAL\n");
 576     cu->SwitchOnCorrectClusterLinearity();
 577   }
 578
 579   printf("ConfigureCaloUtils() - EMCAL Recalibration ON? %d %d\n",recou->IsRecalibrationOn(), cu->IsRecalibrationOn());
 580   printf("ConfigureCaloUtils() - EMCAL BadMap        ON? %d %d\n",recou->IsBadChannelsRemovalSwitchedOn(), cu->IsBadChannelsRemovalSwitchedOn());
 581
 582
 583   if(kCalorimeter=="PHOS")
 584   {
 585     if (kYears <  2014) cu->SetNumberOfSuperModulesUsed(3);
 586     else                cu->SetNumberOfSuperModulesUsed(4);
 587   }
 588   else
 589   {
 590     if      (kYears == 2010) cu->SetNumberOfSuperModulesUsed(4); //EMCAL first year
 591     else if (kYears <  2014) cu->SetNumberOfSuperModulesUsed(10);
 592     else                     cu->SetNumberOfSuperModulesUsed(20);
 593   }
 594
 595   // PHOS
 596   cu->SwitchOffLoadOwnPHOSGeometryMatrices();
 597
 598   if(kPrint) cu->Print("");
 599
 600   return cu;
 601
 602 }
 603
 604 //_____________________________________
 605 AliAnaPhoton* ConfigurePhotonAnalysis()
 606 {
 607
 608   AliAnaPhoton *ana = new AliAnaPhoton();
 609   ana->SetDebug(kDebug); //10 for lots of messages
 610
 611   // cluster selection cuts
 612
 613   ana->SwitchOffFiducialCut();
 614
 615   ana->SetCalorimeter(kCalorimeter);
 616
 617   if(kCalorimeter == "PHOS")
 618   {
 619     ana->SetNCellCut(2);// At least 3 cells
 620     ana->SetMinPt(0.3);
 621     ana->SetMinDistanceToBadChannel(2, 4, 5);
 622     ana->SetTimeCut(-1e10,1e10); // open cut
 623   }
 624   else
 625   {//EMCAL
 626     ana->SetNCellCut(1);// At least 2 cells
 627     ana->SetMinEnergy(0.3); // avoid mip peak at E = 260 MeV
 628     ana->SetMaxEnergy(1000);
 629     ana->SetTimeCut(-1e10,1e10); // open cut, usual time window of [425-825] ns if time recalibration is off
 630     // restrict to less than 100 ns when time calibration is on
 631     ana->SetMinDistanceToBadChannel(2, 4, 6);
 632
 633     // NLM cut, used in all, exclude clusters with more than 2 maxima
 634     // Not needed if M02 cut is already strong or clusterizer V2
 635     ana->SetNLMCut(1, 2) ;
 636   }
 637
 638   if(kTM)
 639   {
 640     ana->SwitchOnTrackMatchRejection() ;
 641     ana->SwitchOffTMHistoFill() ;
 642   }
 643   else
 644   {
 645     ana->SwitchOffTrackMatchRejection() ;
 646     ana->SwitchOnTMHistoFill() ;
 647   }
 648
 649   //PID cuts (shower shape)
 650   ana->SwitchOnCaloPID(); // do PID selection, unless specified in GetCaloPID, selection not based on bayesian
 651   AliCaloPID* caloPID = ana->GetCaloPID();
 652   //Not used in bayesian
 653
 654   //EMCAL
 655   caloPID->SetEMCALLambda0CutMax(0.27);
 656   caloPID->SetEMCALLambda0CutMin(0.10);
 657
 658   caloPID->SetEMCALDEtaCut(0.025);
 659   caloPID->SetEMCALDPhiCut(0.030);
 660
 661   //PHOS
 662   caloPID->SetPHOSDispersionCut(2.5);
 663   caloPID->SetPHOSRCut(2.);
 664   if(kInputData=="AOD") caloPID->SetPHOSRCut(2000.); // Open cut since dX, dZ not stored
 665
 666   ana->SwitchOffFillShowerShapeHistograms();  // Filled before photon shower shape selection
 667   if(!kSimulation)ana->SwitchOnFillPileUpHistograms();
 668   //if(!kSimulation) ana->SwitchOnFillEMCALBCHistograms();
 669
 670   // Input / output delta AOD settings
 671
 672   if(!kData.Contains("delta"))
 673   {
 674     ana->SetOutputAODName(Form("Photon%s",kName.Data()));
 675     ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
 676     //ana->SetOutputAODClassName("AliAODPWG4Particle"); // use if no correlation done
 677   }
 678   else ana->SetInputAODName(Form("Photon%s",kName.Data()));
 679
 680   //Set Histograms name tag, bins and ranges
 681
 682   ana->AddToHistogramsName(Form("AnaPhoton_TM%d_",kTM));
 683   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 684
 685   // Number of particle type MC histograms
 686   ana->FillNOriginHistograms(20);
 687   ana->FillNPrimaryHistograms(20);
 688
 689   ana->SwitchOnRealCaloAcceptance(); // primary particle acceptance histograms
 690   ConfigureMC(ana);
 691
 692   if(kPrint) ana->Print("");
 693
 694   return ana;
 695
 696 }
 697
 698 //________________________________________________________________
 699 AliAnaEMCALTriggerClusters* ConfigureEMCALTriggerClusterAnalysis()
 700 {
 701   // For filling all histograms meaninfully, in the reader, time cut must be off
 702   // and bad triggered events not rejected, and of course analyze triggered events.
 703
 704   AliAnaEMCALTriggerClusters *ana = new AliAnaEMCALTriggerClusters();
 705   ana->SetDebug(kDebug); //10 for lots of messages
 706
 707   // cluster selection cuts
 708
 709   ana->SwitchOffFiducialCut();
 710   ana->SetNCellCut(1);// At least 2 cells
 711   ana->SetMinEnergy(0.3); // avoid mip peak at E = 260 MeV
 712   ana->SetMaxEnergy(1000);
 713   ana->SetM02(1, 2) ;
 714   ana->SwitchOnTrackMatchRejection() ;
 715
 716   ana->AddToHistogramsName("EMCTriggerClusters_");
 717   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 718
 719   if(kPrint) ana->Print("");
 720
 721   return ana;
 722
 723 }
 724
 725 //___________________________________________________
 726 AliAnaClusterPileUp* ConfigureClusterPileUpAnalysis()
 727 {
 728   // For filling all histograms meaninfully, in the reader, time cut must be off
 729   // and bad triggered events in different BC not rejected
 730
 731   AliAnaClusterPileUp *ana = new AliAnaClusterPileUp();
 732   ana->SetDebug(kDebug); //10 for lots of messages
 733
 734   // cluster selection cuts
 735
 736   ana->SwitchOffFiducialCut();
 737   ana->SetNCellCut(1);// At least 2 cells
 738   ana->SetMinEnergy(0.3); // avoid mip peak at E = 260 MeV
 739   ana->SetMaxEnergy(1000);
 740
 741   ana->AddToHistogramsName("ClusterPileUp_");
 742   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 743
 744   if(kPrint) ana->Print("");
 745
 746   return ana;
 747
 748 }
 749
 750 //________________________________________________________________________________
 751 AliAnaElectron* ConfigureElectronAnalysis()
 752 {
 753
 754   AliAnaElectron *ana = new AliAnaElectron();
 755   ana->SetDebug(kDebug); //10 for lots of messages
 756
 757   ana->FillAODWithElectrons();
 758   //ana->FillAODWithHadrons();
 759   //ana->FillAODWithAny();
 760
 761   if(kCalorimeter == "PHOS")
 762   {
 763     ana->SetNCellCut(2);// At least 2 cells
 764     ana->SetMinPt(0.3);
 765     ana->SetMinDistanceToBadChannel(2, 4, 5);
 766   }
 767   else
 768   {//EMCAL
 769     ana->SetNCellCut(1);// At least 2 cells
 770     ana->SetMinPt(0.5); // no effect minium EMCAL cut.
 771     ana->SetMaxPt(100);
 772     //ana->SetTimeCut(400,900);// Time window of [400-900] ns
 773     ana->SetMinDistanceToBadChannel(2, 4, 6);
 774   }
 775
 776   //Electron selection cuts with tracks
 777   ana->SetEOverP(0.85, 1.2);
 778
 779   // TO DO, find a more suitable way to set this
 780   if     (kRunNumber < 146861) ana->SetdEdxCut(72, 90);
 781   else if(kRunNumber < 154000) ana->SetdEdxCut(54, 70);
 782   else                         ana->SetdEdxCut(74, 90);
 783
 784   if(kSimulation)  ana->SetdEdxCut(80, 100);
 785
 786   ana->SetCalorimeter(kCalorimeter);
 787
 788   ana->SwitchOnCaloPID();
 789
 790   AliCaloPID* caloPID = ana->GetCaloPID();
 791
 792   caloPID->SetEMCALLambda0CutMax(0.27);
 793   caloPID->SetEMCALLambda0CutMin(0.10);
 794
 795   ana->SwitchOffFillShowerShapeHistograms();
 796   ana->SwitchOffFillWeightHistograms()  ;
 797   ana->SwitchOffFiducialCut();
 798
 799   if(!kData.Contains("delta"))
 800   {
 801     ana->SetOutputAODName(Form("Electron%s",kName.Data()));
 802     ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
 803   }
 804   else ana->SetInputAODName(Form("Electron%s",kName.Data()));
 805
 806   //Set Histograms name tag, bins and ranges
 807
 808   ana->AddToHistogramsName(Form("AnaElectron_TM%d_",kTM));
 809   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 810
 811   ConfigureMC(ana);
 812
 813   if(kPrint) ana->Print("");
 814
 815   return ana ;
 816
 817 }
 818
 819 //__________________________________________________________________________________________
 820 AliAnaRandomTrigger* ConfigureRandomTriggerAnalysis(TString detector = "")
 821 {
 822
 823   AliAnaRandomTrigger *ana = new AliAnaRandomTrigger();
 824   ana->SetDebug(kDebug); //10 for lots of messages
 825
 826   if(detector=="") detector = kCalorimeter;
 827   ana->SetDetector(detector);
 828
 829   // selection cuts
 830   ana->SetMinPt(4.);
 831   ana->SetMaxPt(51.);
 832
 833   if     (detector=="EMCAL")
 834   {
 835     ana->SetEtaCut(-0.71,0.71);
 836     ana->SetPhiCut(100*TMath::DegToRad(), 160*TMath::DegToRad());
 837   }
 838   else if(detector=="PHOS")
 839   {
 840     ana->SetEtaCut(-0.13,0.13);
 841     ana->SetPhiCut(260*TMath::DegToRad(), 320*TMath::DegToRad());
 842   }
 843   else if(detector=="CTS")
 844   {
 845     ana->SetEtaCut(-0.9,0.9);
 846     ana->SetPhiCut(0, TMath::TwoPi());
 847   }
 848
 849   // AOD branch
 850   if(!kData.Contains("delta"))
 851   {
 852     ana->SetOutputAODName(Form("RandomTrigger%s%s",detector.Data(),kName.Data()));
 853     ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
 854   }
 855   else
 856     ana->SetInputAODName(Form("RandomTrigger%s%s",detector.Data(),kName.Data()));
 857
 858   printf("Set RandomTrigger%s%s\n",detector.Data(),kName.Data());
 859
 860   //Set Histograms name tag, bins and ranges
 861
 862   ana->AddToHistogramsName(Form("AnaRandomTrigger%s_",detector.Data()));
 863
 864   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 865
 866   if(detector=="CTS")
 867   {
 868     ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ;
 869     ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ;
 870   }
 871
 872   if(kPrint) ana->Print("");
 873
 874   return ana;
 875
 876 }
 877
 878 //__________________________________________________________________________________________
 879 AliAnaInsideClusterInvariantMass* ConfigureInClusterIMAnalysis(Bool_t useSS = kTRUE, Bool_t useAsy = kFALSE)
 880 {
 881   AliAnaInsideClusterInvariantMass *ana = new AliAnaInsideClusterInvariantMass();
 882   ana->SetDebug(kDebug); //10 for lots of messages
 883
 884   // selection cuts
 885
 886   ana->SetMinEnergy(6);
 887   ana->SetMaxEnergy(200.);
 888   ana->SetMinNCells(6); // check same as in calopid
 889
 890   ana->SetCalorimeter(kCalorimeter);
 891   ana->SwitchOnSplitClusterDistToBad();
 892
 893   ana->SwitchOffFillSSWeightHistograms() ;
 894   ana->SetNWeightForShowerShape(0);
 895   //ana->SetWeightForShowerShape(0, 4.6);
 896
 897   ana->SwitchOnFillNCellHistograms();
 898   ana->SwitchOffFillEbinHistograms();
 899   if(!useSS && !useAsy) ana->SwitchOnFillEbinHistograms();
 900
 901   if(!kTM)
 902   {
 903     ana->SwitchOnFillTMHistograms();
 904     ana->SwitchOnFillTMResidualHistograms();
 905   }
 906   else
 907   {
 908     ana->SwitchOffFillTMHistograms();
 909     ana->SwitchOffFillTMResidualHistograms();
 910   }
 911
 912   //printf("Set correction slope for SS weight \n");
 913   //ana->SetWCorrectionParameter(0.07);
 914   //ana->SetNECellCutForShowerShape(0);
 915   //ana->SetECellCutForShowerShape(0, 0.07);
 916   //ana->SetECellCutForShowerShape(1, 0.1);
 917   //ana->SetECellCutForShowerShape(2, 0.2);
 918
 919   if(kSimulation)
 920   {
 921     ana->SwitchOnFillMCPrimaryHistograms() ;
 922     ana->SwitchOffFillMCOverlapHistograms() ; // Off when possible
 923     if(!useSS && !useAsy) ana->SwitchOnFillMCOverlapHistograms() ;
 924   }
 925
 926   AliCaloPID* caloPID = ana->GetCaloPID();
 927   caloPID->SetEMCALDEtaCut(0.025);
 928   caloPID->SetEMCALDPhiCut(0.030);
 929   caloPID->SetClusterSplittingM02Cut(0,100000); // use parametrized cut, not fixed
 930
 931   caloPID->SetPi0MassRange(0.11, 0.18);
 932   caloPID->SetEtaMassRange(0.40, 0.60);
 933   caloPID->SetPhotonMassRange(0.00, 0.08);
 934
 935   caloPID->SetSplitWidthSigma(3.); // cut at 3 sigma of the mean pi0 peak.
 936
 937   caloPID->SetClusterSplittingMinNCells(6);
 938
 939   if(kCollisions=="PbPb" || kName.Contains("150"))
 940   {
 941     caloPID->SetClusterSplittingMinNCells(4);
 942     ana->SetMinNCells(4);
 943     caloPID->SetPi0MassShiftHighECell(0.005);
 944     if(kCollisions=="PbPb") ana->SwitchOnFillHighMultHistograms();
 945   }
 946
 947   ana->AddToHistogramsName("AnaInClusterIM_");
 948
 949   if(useAsy)
 950   {
 951     caloPID->SwitchOnSplitAsymmetryCut() ;
 952   }
 953   else
 954   {
 955     printf("InClusterIM: Do not apply Asy cut on merged pi0 in cluster analysis \n");
 956     caloPID->SwitchOffSplitAsymmetryCut() ;
 957     ana->AddToHistogramsName("AnaInClusterIM_OpenAsy_");
 958   }
 959
 960   if(!useSS)
 961   {
 962     printf("InClusterIM: Do not apply SS cut on merged pi0 in cluster analysis \n");
 963     caloPID->SwitchOffSplitShowerShapeCut() ;
 964     ana->AddToHistogramsName("AnaInClusterIM_OpenSS_");
 965   }
 966   else  caloPID->SwitchOnSplitShowerShapeCut() ;
 967
 968   if(!useAsy && !useSS)
 969   {
 970     printf("InClusterIM: Do not apply SS and Asy cut on merged pi0 in cluster analysis \n");
 971     ana->AddToHistogramsName("AnaInClusterIM_OpenSS_OpenAsy_");
 972   }
 973
 974   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
 975
 976   ConfigureMC(ana);
 977
 978   if(kPrint) ana->Print("");
 979
 980   return ana;
 981
 982 }
 983
 984 //_______________________________________________
 985 AliAnaChargedParticles* ConfigureChargedAnalysis()
 986 {
 987
 988   AliAnaChargedParticles *ana = new AliAnaChargedParticles();
 989   ana->SetDebug(kDebug); //10 for lots of messages
 990
 991   // selection cuts
 992
 993   ana->SetMinPt(0.5);
 994   ana->SwitchOnFiducialCut();
 995   ana->GetFiducialCut()->SetSimpleCTSFiducialCut(0.8, 0, 360) ; //more restrictive cut in reader and after in isolation
 996
 997   ana->SwitchOnFillVertexBC0Histograms() ;
 998   if(!kSimulation) ana->SwitchOnFillPileUpHistograms();
 999
1000   // Input / output delta AOD settings
1001
1002   if(!kData.Contains("delta"))
1003   {
1004     ana->SetOutputAODName(Form("Hadron%s",kName.Data()));
1005     ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
1006     //ana->SetOutputAODClassName("AliAODPWG4Particle"); // use if no correlation done
1007   }
1008   else
1009     ana->SetInputAODName(Form("Hadron%s",kName.Data()));
1010   printf("Set Hadron%s\n",kName.Data());
1011
1012   //Set Histograms name tag, bins and ranges
1013
1014   ana->AddToHistogramsName("AnaHadrons_");
1015   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
1016
1017   ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ;
1018   ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ;
1019
1020   ConfigureMC(ana);
1021
1022   if(kPrint) ana->Print("");
1023
1024   return ana;
1025
1026 }
1027
1028
1029 //_____________________________________________________
1030 AliAnaPi0EbE* ConfigurePi0EbEAnalysis(TString particle,
1031                                       Int_t analysis, Bool_t useSS = kTRUE, Bool_t useAsy = kTRUE)
1032 {
1033
1034   AliAnaPi0EbE *ana = new AliAnaPi0EbE();
1035   ana->SetDebug(kDebug);//10 for lots of messages
1036
1037   ana->SetAnalysisType(analysis);
1038   TString opt = "";
1039   if(analysis == AliAnaPi0EbE::kIMCaloTracks) opt = "Conv";
1040   if(analysis == AliAnaPi0EbE::kSSCalo)       opt = "SS";
1041
1042   if(analysis == AliAnaPi0EbE::kIMCalo && kCalorimeter=="EMCAL" && !kSimulation) ana->SetPairTimeCut(100);
1043   if(analysis == AliAnaPi0EbE::kIMCaloTracks) ana->SetInputAODGammaConvName("PhotonsCTS");
1044
1045   // Common settings for all 3 type of analysis
1046
1047   ana->SwitchOnSelectedClusterHistoFill();
1048
1049   ana->SetCalorimeter(kCalorimeter);
1050
1051   //Set Histograms name tag, bins and ranges
1052   ana->AddToHistogramsName(Form("Ana%s%sEbE_TM%d_",particle.Data(),opt.Data(),kTM));
1053
1054   // Specific settings for different type of analysis
1055
1056   ana->SwitchOffFillWeightHistograms();
1057   if(!kSimulation) ana->SwitchOnFillPileUpHistograms();
1058
1059   if(kTM)
1060   {
1061     //printf("--->>>REMOVE MATCHED Pi0\n");
1062     ana->SwitchOnTrackMatchRejection() ;
1063     ana->SwitchOffTMHistoFill() ;
1064   }
1065   else
1066   {
1067     //printf("---->>>ACCEPT MATCHED Pi0\n");
1068     ana->SwitchOffTrackMatchRejection() ;
1069     ana->SwitchOnTMHistoFill() ;
1070   }
1071
1072   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
1073
1074   //ana->SwitchOnFillEMCALBCHistograms();
1075
1076   if(kPrint) ana->Print("");
1077
1078   ConfigureMC(ana);
1079
1080   if(!kInputDataType.Contains("delta"))
1081   {
1082     ana->SetOutputAODName(Form("%s%s%s",particle.Data(), opt.Data(), kName.Data()));
1083     ana->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
1084
1085   }
1086   else
1087     ana->SetInputAODName(Form("%s%s%s",particle.Data(),opt.Data(),kName.Data()));
1088
1089   if(analysis!=AliAnaPi0EbE::kSSCalo)
1090   {
1091     // Input / output delta AOD settings
1092
1093     ana->SetInputAODName(Form("Photon%s",kName.Data()));
1094
1095     AliNeutralMesonSelection *nms = ana->GetNeutralMesonSelection();
1096     nms->SetParticle(particle);
1097
1098     // Tighten a bit mass cut with respect to default window
1099     if(particle=="Pi0") nms->SetInvMassCutRange(0.120,0.150);
1100     if(particle=="Eta") nms->SetInvMassCutRange(0.520,0.580);
1101
1102     //if(!particle.Contains("SideBand")) nms->SwitchOnAngleSelection();
1103     //else nms->SwitchOnAngleSelection();
1104
1105     nms->SwitchOffAngleSelection();
1106     if(particle.Contains("Pi0SideBand")) // For pi0, do not consider left band
1107       nms->SetSideBandCutRanges(-1,0,0.180,0.220);
1108
1109     nms->KeepNeutralMesonSelectionHistos(kTRUE);
1110     //nms->SetAngleMaxParam(2,0.2);
1111     nms->SetHistoERangeAndNBins(0, 20, 80) ;
1112     //nms->SetHistoIMRangeAndNBins(0, 1, 400);
1113   }
1114   else
1115   { // cluster splitting settings
1116     ana->SetMinEnergy(6);
1117     ana->SetMaxEnergy(200.);
1118
1119     ana->SetNLMMinEnergy(0, 10);
1120     ana->SetNLMMinEnergy(1, 6);
1121     ana->SetNLMMinEnergy(2, 6);
1122
1123     ana->SetMinDistanceToBadChannel(2, 4, 6); // only use the first one
1124     ana->SwitchOnSplitClusterDistToBad();
1125
1126     ana->SetTimeCut(-1e10,1e10); // Open time cut
1127
1128     // NLM cut, used in all, exclude clusters with more than 2 maxima
1129     ana->SetNLMCut(1, 2) ;
1130
1131     AliCaloPID* caloPID = ana->GetCaloPID();
1132
1133     caloPID->SetSplitWidthSigma(3.); // cut at 3 sigma of the mean pi0 peak.
1134
1135     if(!useSS)
1136     {
1137       printf("Do not apply SS cut on merged pi0 analysis \n");
1138       caloPID->SwitchOffSplitShowerShapeCut() ;
1139       ana->AddToHistogramsName(Form("Ana%s%sEbE_OpenSS_TM%d_",particle.Data(),opt.Data(),kTM));
1140       ana->SetOutputAODName(Form("%s%s%s_OpenSS",particle.Data(), opt.Data(), kName.Data()));
1141       caloPID->SetClusterSplittingM02Cut(0.1,10000);
1142     }
1143     else
1144     {
1145       caloPID->SetClusterSplittingM02Cut(0.3,5); // Do the selection in the analysis class and not in the PID method to fill SS histograms
1146       caloPID->SwitchOnSplitShowerShapeCut() ;
1147     }
1148
1149     if(useAsy) caloPID->SwitchOnSplitAsymmetryCut() ;
1150     else
1151     {
1152       caloPID->SwitchOffSplitAsymmetryCut() ;
1153       if(!useSS)
1154       {
1155         ana->AddToHistogramsName(Form("Ana%s%sEbE_OpenSS_OpenAsy_TM%d_",particle.Data(),opt.Data(),kTM));
1156         ana->SetOutputAODName(Form("%s%s%s_OpenSS_OpenAsy",particle.Data(), opt.Data(), kName.Data()));
1157       }
1158       else
1159       {
1160         ana->AddToHistogramsName(Form("Ana%s%sEbE_OpenAsy_TM%d_",particle.Data(),opt.Data(),kTM));
1161         ana->SetOutputAODName(Form("%s%s%s_OpenAsy",particle.Data(), opt.Data(), kName.Data()));
1162       }
1163     }
1164
1165     //For Pi0 only if  SwitchOnSimpleSplitMassCut()
1166     caloPID->SetPi0MassRange(0.10, 0.18);
1167     caloPID->SetEtaMassRange(0.40, 0.60);
1168     caloPID->SetPhotonMassRange(0.00, 0.08);
1169
1170     caloPID->SetClusterSplittingMinNCells(6);
1171
1172     //caloPID->SetSplitEnergyFractionMinimum(0, 0.95);
1173     //caloPID->SetSplitEnergyFractionMinimum(1, 0.95);
1174     //caloPID->SetSplitEnergyFractionMinimum(2, 0.8);
1175
1176     if(kCollisions=="PbPb" || kName.Contains("150"))
1177     {
1178       caloPID->SetClusterSplittingMinNCells(4);
1179       caloPID->SetPi0MassShiftHighECell(0.005);
1180     }
1181   }
1182
1183   return  ana;
1184
1185 }
1186
1187 //____________________________________________________________________________________________________
1188 AliAnaParticleIsolation* ConfigureIsolationAnalysis(TString particle="Photon",
1189                                                     Int_t  partInCone = AliIsolationCut::kOnlyCharged,
1190                                                     Int_t  thresType  = AliIsolationCut::kSumPtFracIC,
1191                                                     Float_t cone = 0.3,
1192                                                     Float_t pth  = 0.3,
1193                                                     Bool_t multi      = kFALSE)
1194 {
1195
1196   AliAnaParticleIsolation *ana = new AliAnaParticleIsolation();
1197   //ana->SetDebug(kDebug);
1198   ana->SetDebug(kDebug);
1199
1200   ana->SwitchOnFiducialCut();
1201   //Avoid borders of EMCal
1202   if(kCalorimeter=="EMCAL")
1203     ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.6, 86, 174) ;
1204
1205   // Same Eta as EMCal, cut in phi if EMCAL was triggering
1206   if(particle=="Hadron"  || particle.Contains("CTS"))
1207   {
1208    // if(kTrig.Contains("EMC"))
1209    //   ana->GetFiducialCut()->SetSimpleCTSFiducialCut  (0.6, 260, 360) ;
1210    // else
1211       ana->GetFiducialCut()->SetSimpleCTSFiducialCut  (0.6, 0, 360) ;
1212   }
1213
1214   ana->SetMinPt(5);
1215
1216   // Input / output delta AOD settings
1217
1218   ana->SetInputAODName(Form("%s%s",particle.Data(),kName.Data()));
1219   ana->SetAODObjArrayName(Form("IC%s_%s",particle.Data(),kName.Data()));
1220
1221   ana->SetCalorimeter(kCalorimeter);
1222
1223   if(!kTM)  ana->SwitchOnTMHistoFill();
1224   else      ana->SwitchOffTMHistoFill();
1225
1226   ana->SwitchOffSSHistoFill();
1227   if(!kSimulation) ana->SwitchOnFillPileUpHistograms();
1228
1229   //Do settings for main isolation cut class
1230   AliIsolationCut * ic =  ana->GetIsolationCut();
1231   ic->SetDebug(kDebug);
1232
1233   if(cone >0 && pth > 0)
1234   {
1235     ic->SetPtThreshold(pth);
1236     ic->SetConeSize(cone);
1237   }
1238   else
1239   {
1240     if(kCollisions=="pp")
1241     {
1242       ic->SetPtThreshold(0.5);
1243       ic->SetConeSize(0.4);
1244     }
1245     if(kCollisions=="PbPb")
1246     {
1247       ic->SetPtThreshold(3.);
1248       //ic->SetPtThreshold(1.);
1249       ic->SetConeSize(0.3);
1250     }
1251   }
1252
1253   ic->SetPtFraction(0.1);
1254   ic->SetSumPtThreshold(1.0) ;
1255   ic->SetParticleTypeInCone(partInCone);
1256   ic->SetICMethod(thresType);
1257
1258   //Do or not do isolation with previously produced AODs.
1259   //No effect if use of SwitchOnSeveralIsolation()
1260   ana->SwitchOffReIsolation();
1261
1262   //Multiple IC
1263   if(multi)
1264   {
1265     ic->SetConeSize(1.);    // Take all for first iteration
1266     ic->SetPtThreshold(100);// Take all for first iteration
1267     ana->SwitchOnSeveralIsolation() ;
1268     ana->SetAODObjArrayName(Form("MultiIC%sTM%d",particle.Data(),kTM));
1269
1270     ana->SetNCones(4);
1271     ana->SetNPtThresFrac(4);
1272     ana->SetConeSizes(0,0.3);       ana->SetConeSizes(1,0.4);
1273     ana->SetConeSizes(2,0.5);       ana->SetConeSizes(3,0.6);
1274     ana->SetPtThresholds(0, 0.5);   ana->SetPtThresholds(1, 1);     ana->SetPtThresholds(2, 2);
1275     ana->SetPtFractions (0, 0.05) ; ana->SetPtFractions (1, 0.1);   ana->SetPtFractions (2, 0.2) ;  ana->SetPtFractions (3, 0.3) ;
1276     ana->SetSumPtThresholds(0, 1) ; ana->SetSumPtThresholds(1, 3) ; ana->SetSumPtThresholds(2, 5);  ana->SetSumPtThresholds(3, 7)  ;
1277
1278     ana->SwitchOffTMHistoFill();
1279     ana->SwitchOffSSHistoFill();
1280   }
1281   else
1282     ana->SwitchOffSeveralIsolation() ;
1283
1284   AliCaloPID* caloPID = ana->GetCaloPID();
1285   caloPID->SetEMCALDEtaCut(0.025);
1286   caloPID->SetEMCALDPhiCut(0.030);
1287
1288   //Set Histograms name tag, bins and ranges
1289
1290   if(!multi)ana->AddToHistogramsName(Form("AnaIsol%s_TM%d_",particle.Data(),kTM));
1291   else      ana->AddToHistogramsName(Form("AnaMultiIsol%s_TM%d_",particle.Data(),kTM));
1292
1293   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
1294
1295   if(particle=="Hadron"  || particle.Contains("CTS"))
1296   {
1297     ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ;
1298     ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ;
1299   }
1300
1301   ana->SwitchOnRealCaloAcceptance(); // primary particle acceptance histograms
1302   ConfigureMC(ana);
1303
1304   if(kPrint) ic ->Print("");
1305   if(kPrint) ana->Print("");
1306
1307   return ana;
1308
1309 }
1310
1311 //___________________________________________________________________________________
1312 AliAnaParticleHadronCorrelation* ConfigureHadronCorrelationAnalysis(TString particle,
1313                                                                     Bool_t bIsolated,
1314                                                                     Int_t  partInCone = AliIsolationCut::kOnlyCharged,
1315                                                                     Int_t  thresType  = AliIsolationCut::kSumPtFracIC,
1316                                                                     Float_t cone = 0.3,
1317                                                                     Float_t pth  = 0.3)
1318 {
1319
1320   AliAnaParticleHadronCorrelation *ana = new AliAnaParticleHadronCorrelation();
1321   ana->SetDebug(kDebug);
1322
1323   ana->SetTriggerPtRange(5,100);
1324   ana->SetAssociatedPtRange(0.2,100);
1325   ana->SetDeltaPhiCutRange( TMath::Pi()/2,3*TMath::Pi()/2 ); //[90 deg, 270 deg]
1326
1327   ana->SetNAssocPtBins(9);
1328
1329   ana->SetAssocPtBinLimit(0, 0.2) ;
1330   ana->SetAssocPtBinLimit(1, 0.5) ;
1331   ana->SetAssocPtBinLimit(2, 1)   ;
1332   ana->SetAssocPtBinLimit(3, 2)   ;
1333   ana->SetAssocPtBinLimit(4, 3)   ;
1334   ana->SetAssocPtBinLimit(5, 4)   ;
1335   ana->SetAssocPtBinLimit(6, 6)   ;
1336   ana->SetAssocPtBinLimit(7, 10)  ;
1337   ana->SetAssocPtBinLimit(8, 30)  ;
1338   ana->SetAssocPtBinLimit(9, 200) ;
1339
1340   ana->SelectIsolated(bIsolated); // do correlation with isolated photons
1341
1342   if(bIsolated)
1343   {
1344     //Do settings for main isolation cut class
1345     AliIsolationCut * ic =  ana->GetIsolationCut();
1346     ic->SetDebug(kDebug);
1347
1348     if(cone >0 && pth > 0)
1349     {
1350       ic->SetPtThreshold(pth);
1351       ic->SetConeSize(cone);
1352     }
1353     else
1354     {
1355       if(kCollisions=="pp")
1356       {
1357         ic->SetPtThreshold(0.5);
1358         ic->SetConeSize(0.4);
1359       }
1360       if(kCollisions=="PbPb")
1361       {
1362         ic->SetPtThreshold(3.);
1363         //ic->SetPtThreshold(1.);
1364         ic->SetConeSize(0.3);
1365       }
1366     }
1367
1368     ic->SetPtFraction(0.1);
1369     ic->SetSumPtThreshold(1.0) ;
1370     ic->SetParticleTypeInCone(partInCone);
1371     ic->SetICMethod(thresType);
1372
1373   }
1374
1375   ana->SwitchOnAbsoluteLeading();  // Select trigger leading particle of all the selected tracks
1376   ana->SwitchOffNearSideLeading(); // Select trigger leading particle of all the particles at +-90 degrees, default
1377
1378   // Mixing with own pool
1379   if(kMix)
1380   {
1381     ana->SwitchOnOwnMix();
1382     ana->SwitchOnFillNeutralInMixedEvent();
1383   }
1384   else
1385     ana->SwitchOffOwnMix();
1386
1387   ana->SetNZvertBin(20);
1388
1389   if(kCollisions=="pp")
1390   {
1391     ana->SetNMaxEvMix(100);
1392     ana->SwitchOnTrackMultBins();
1393     ana->SetNCentrBin(9); // Fixed track mult values
1394     ana->SetNRPBin(1);
1395   }
1396   else
1397   {
1398     ana->SetNMaxEvMix(10);
1399     ana->SwitchOffTrackMultBins(); // centrality bins
1400     ana->SetNCentrBin(3);
1401     ana->SetNRPBin(3);
1402     if(kName.Contains("60_90"))
1403     {
1404       printf("*** Set mixing for peripheral\n");
1405       ana->SetNMaxEvMix(50);
1406       ana->SetNCentrBin(2);
1407     }
1408   }
1409
1410   ana->SwitchOnFiducialCut();
1411
1412   //Avoid borders of EMCal, same as for isolation
1413   if(kCalorimeter=="EMCAL")
1414     ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.6, 86, 174) ;
1415
1416   // Same Eta as EMCal, cut in phi if EMCAL was triggering
1417   if(particle=="Hadron" || particle.Contains("CTS"))
1418   {
1419     //if(kTrig.Contains("EMC"))
1420     //  ana->GetFiducialCut()->SetSimpleCTSFiducialCut  (0.6, 260, 360) ;
1421     //else
1422       ana->GetFiducialCut()->SetSimpleCTSFiducialCut  (0.6, 0, 360) ;
1423   }
1424
1425   // Input / output delta AOD settings
1426
1427   ana->SetInputAODName(Form("%s%s",particle.Data(),kName.Data()));
1428   ana->SetAODObjArrayName(Form("%sHadronCorrIso%d_%s",particle.Data(),bIsolated,kName.Data()));
1429
1430   // Fill extra plots on tagged decay photons
1431   // If trigger is pi0/eta found with invariant mass, get the decays
1432   // If trigger is photon, check if it was tagged as decay previously
1433   if(particle!="Hadron" )
1434   {
1435     if(particle.Contains("Pi0") || particle.Contains("Eta"))
1436     {
1437       ana->SwitchOffPi0TriggerDecayCorr();
1438       ana->SwitchOffDecayTriggerDecayCorr();
1439     }
1440     else
1441     {
1442       ana->SwitchOffPi0TriggerDecayCorr();
1443       ana->SwitchOnDecayTriggerDecayCorr(); // Make sure pi0 decay tagging runs before this task
1444     }
1445   }
1446   else
1447   {
1448     ana->SwitchOffPi0TriggerDecayCorr();
1449     ana->SwitchOffDecayTriggerDecayCorr();
1450   }
1451
1452   if(particle=="Photon")
1453   {
1454     printf("**** SET M02 limits *** \n");
1455     ana->SetM02Cut(0.1,0.27);
1456   }
1457
1458   // if triggering on PHOS and EMCAL is on
1459   //if(kCalorimeter=="PHOS") ana->SwitchOnNeutralCorr();
1460   ana->SwitchOffNeutralCorr(); // Do only correlation with TPC
1461
1462   ana->SwitchOffHMPIDCorrelation();
1463
1464   ana->SwitchOffFillBradHistograms();
1465
1466   // Underlying event
1467   ana->SwitchOffEventSelection();
1468   ana->SwitchOnSeveralUECalculation();
1469   ana->SetUeDeltaPhiCutRange(TMath::Pi()/3, 2*TMath::Pi()/3);
1470   ana->SetMultiBin(1);
1471
1472   //Set Histograms name tag, bins and ranges
1473
1474   ana->AddToHistogramsName(Form("Ana%sHadronCorr_Iso%d_TM%d_",particle.Data(),bIsolated,kTM));
1475   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
1476
1477   if(particle=="Hadron"  || particle.Contains("CTS"))
1478   {
1479     ana->GetHistogramRanges()->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 200) ;
1480     ana->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-1.5, 1.5, 300) ;
1481   }
1482
1483   ConfigureMC(ana);
1484
1485   if(kPrint) ana->Print("");
1486
1487   return ana;
1488
1489 }
1490
1491 //________________________________________
1492 AliAnaCalorimeterQA* ConfigureQAAnalysis()
1493 {
1494
1495   AliAnaCalorimeterQA *ana = new AliAnaCalorimeterQA();
1496   ana->SetDebug(kDebug); //10 for lots of messages
1497   ana->SetCalorimeter(kCalorimeter);
1498
1499   ana->SetTimeCut(-1e10,1e10); // Open time cut
1500
1501   // Study inter detector correlation (PHOS, EMCAL, Tracks, V0)
1502   if(kCalorimeter=="PHOS"  && kTrig=="PHOS")
1503     ana->SwitchOnCorrelation(); // make sure you switch in the reader PHOS and EMCAL cells and clusters if option is ON
1504   if(kCalorimeter=="EMCAL" && kClusterArray=="")
1505     ana->SwitchOnCorrelation(); // make sure you switch in the reader PHOS and EMCAL cells and clusters if option is ON
1506   else
1507     ana->SwitchOffCorrelation();
1508
1509   // Study exotic clusters PHOS and EMCAL
1510   if(kClusterArray=="") ana->SwitchOnStudyBadClusters() ;
1511   else                  ana->SwitchOffStudyBadClusters() ;
1512
1513
1514   ana->SwitchOffFiducialCut();
1515   ana->SwitchOffFillAllTH3Histogram();
1516   ana->SwitchOffFillAllPositionHistogram();
1517   ana->SwitchOffFillAllPositionHistogram2();
1518   if(!kExotic)ana->SwitchOnStudyBadClusters();
1519   else        ana->SwitchOffStudyBadClusters();
1520   ana->SwitchOffStudyClustersAsymmetry();
1521   ana->SwitchOffStudyWeight();
1522   ana->SwitchOnFillAllTrackMatchingHistogram();
1523   ana->SwitchOnFillAllCellTimeHisto() ;
1524
1525   ana->AddToHistogramsName("QA_"); //Begining of histograms name
1526   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
1527
1528   ConfigureMC(ana);
1529
1530   if(kPrint) ana->Print("");
1531
1532   return ana;
1533
1534 }
1535
1536 //________________________________________________________________
1537 AliAnaGeneratorKine* ConfigureGenKineAnalysis()
1538 {
1539   // Analysis for parton, jets correlation with photon and pi0
1540
1541   AliAnaGeneratorKine *ana = new AliAnaGeneratorKine();
1542   ana->SetDebug(kDebug); //10 for lots of messages
1543
1544   // Trigger detector, acceptance and pT cut
1545   ana->SetTriggerDetector("EMCAL");
1546   ana->SetMinPt(10); // Trigger photon, pi0 minimum pT
1547   ana->GetFiducialCutForTrigger()->SetSimpleEMCALFiducialCut(0.6, 85, 175);
1548
1549   // Particles associated to trigger or isolation cone acceptance and pT cut
1550   ana->SetCalorimeter("EMCAL");
1551   ana->SetMinChargedPt(0.2);
1552   ana->SetMinNeutralPt(0.3);
1553   ana->GetFiducialCut()->SetSimpleEMCALFiducialCut(0.65, 81, 179);
1554   ana->GetFiducialCut()->SetSimpleCTSFiducialCut(0.9, 0, 360);
1555
1556   // Isolation paramters
1557   AliIsolationCut * ic =  ana->GetIsolationCut();
1558   ic->SetDebug(kDebug);
1559   ic->SetPtThreshold(0.5);
1560   ic->SetConeSize(0.5);
1561   ic->SetSumPtThreshold(1.0) ;
1562   ic->SetICMethod(AliIsolationCut::kPtThresIC); // kSumPtIC
1563
1564   ana->AddToHistogramsName("AnaGenKine_");
1565   SetHistoRangeAndNBins(ana->GetHistogramRanges()); // see method below
1566
1567   if(kPrint) ana->Print("");
1568
1569   return ana;
1570
1571 }
1572
1573 //________________________________________________________
1574 void ConfigureMC(AliAnaCaloTrackCorrBaseClass* ana)
1575 {
1576   if(kSimulation) ana->SwitchOnDataMC() ;//Access MC stack and fill more histograms, AOD MC not implemented yet.
1577   else            ana->SwitchOffDataMC() ;
1578
1579   //Set here generator name, default pythia
1580   //ana->GetMCAnalysisUtils()->SetMCGenerator("");
1581 }
1582
1583 //________________________________________________________
1584 void SetHistoRangeAndNBins (AliHistogramRanges* histoRanges)
1585 {
1586   // Set common bins for all analysis and MC histograms filling
1587
1588   histoRanges->SetHistoPtRangeAndNBins(0, 100, 200) ; // Energy and pt histograms
1589
1590   if(kCalorimeter=="EMCAL")
1591   {
1592     if(kYears==2010)
1593     {
1594       histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 122*TMath::DegToRad(), 78) ;
1595       histoRanges->SetHistoXRangeAndNBins(-230,90,120); // QA
1596       histoRanges->SetHistoYRangeAndNBins(370,450,40);  // QA
1597     }
1598     else if(kYears==2011)
1599     {
1600       histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 182*TMath::DegToRad(), 108) ;
1601       histoRanges->SetHistoXRangeAndNBins(-600,90,200); // QA
1602       histoRanges->SetHistoYRangeAndNBins(100,450,100); // QA
1603     }
1604     else
1605     {
1606       histoRanges->SetHistoPhiRangeAndNBins(78*TMath::DegToRad(), 190*TMath::DegToRad(), 122) ;
1607       histoRanges->SetHistoXRangeAndNBins(-100,90,200); // QA
1608       histoRanges->SetHistoYRangeAndNBins(50,450,100);  // QA
1609     }
1610
1611     histoRanges->SetHistoEtaRangeAndNBins(-0.72, 0.72, 144) ;
1612   }
1613   else
1614   {
1615     histoRanges->SetHistoPhiRangeAndNBins(260*TMath::DegToRad(), 320*TMath::DegToRad(), 60) ;
1616     histoRanges->SetHistoEtaRangeAndNBins(-0.13, 0.13, 130) ;
1617   }
1618
1619   histoRanges->SetHistoShowerShapeRangeAndNBins(-0.1, 4.9, 500);
1620
1621   // Invariant mass histoRangeslysis
1622   histoRanges->SetHistoMassRangeAndNBins(0., 1., 200) ;
1623   histoRanges->SetHistoAsymmetryRangeAndNBins(0., 1. , 100) ;
1624
1625   // check if time calibration is on
1626   histoRanges->SetHistoTimeRangeAndNBins(-1000.,1000,1000);
1627   histoRanges->SetHistoDiffTimeRangeAndNBins(-200, 200, 800);
1628
1629   // track-cluster residuals
1630   histoRanges->SetHistoTrackResidualEtaRangeAndNBins(-0.15,0.15,300);
1631   histoRanges->SetHistoTrackResidualPhiRangeAndNBins(-0.15,0.15,300);
1632   histoRanges->SetHistodRRangeAndNBins(0.,0.15,150);//QA
1633
1634   // QA, electron, charged
1635   histoRanges->SetHistoPOverERangeAndNBins(0,  2.5 ,500);
1636   histoRanges->SetHistodEdxRangeAndNBins  (0.,250.0,500);
1637
1638   // QA
1639   histoRanges->SetHistoFinePtRangeAndNBins(0, 10, 200) ; // bining for fhAmpId
1640   histoRanges->SetHistoRatioRangeAndNBins(0.,2.,100);
1641   histoRanges->SetHistoVertexDistRangeAndNBins(0.,500.,500);
1642   histoRanges->SetHistoNClusterCellRangeAndNBins(0,50,50);
1643   histoRanges->SetHistoZRangeAndNBins(-400,400,200);
1644   histoRanges->SetHistoRRangeAndNBins(400,450,25);
1645   histoRanges->SetHistoV0SignalRangeAndNBins(0,5000,500);
1646   histoRanges->SetHistoV0MultiplicityRangeAndNBins(0,5000,500);
1647   histoRanges->SetHistoTrackMultiplicityRangeAndNBins(0,5000,500);
1648
1649   // Isolation
1650   histoRanges->SetHistoPtInConeRangeAndNBins(0, 50 , 250);
1651   histoRanges->SetHistoPtSumRangeAndNBins   (0, 100, 250);
1652
1653 }
1654
1655 //_____________________________
1656 UInt_t SetTriggerMaskFromName()
1657 {
1658   if(kTrig=="EMC7")
1659   {
1660     printf("CaloTrackCorr trigger EMC7\n");
1661     return AliVEvent::kEMC7;
1662   }
1663   else if (kTrig=="INT7")
1664   {
1665     printf("CaloTrackCorr trigger INT7\n");
1666     return AliVEvent::kINT7;
1667   }
1668   else if(kTrig=="EMC1")
1669   {
1670     printf("CaloTrackCorr trigger EMC1\n");
1671     return AliVEvent::kEMC1;
1672   }
1673   else if(kTrig=="MB")
1674   {
1675     printf("CaloTrackCorr trigger MB\n");
1676     return AliVEvent::kMB;
1677   }
1678   else if(kTrig=="PHOS")
1679   {
1680     printf("CaloTrackCorr trigger PHOS\n");
1681     return AliVEvent::kPHI7;
1682   }
1683   else if(kTrig=="PHOSPb")
1684   {
1685     printf("CaloTrackCorr trigger PHOSPb\n");
1686     return AliVEvent::kPHOSPb;
1687   }
1688   else if(kTrig=="AnyINT")
1689   {
1690     printf("CaloTrackCorr trigger AnyINT\n");
1691     return AliVEvent::kAnyINT;
1692   }
1693   else if(kTrig=="INT")
1694   {
1695     printf("CaloTrackCorr trigger AnyINT\n");
1696     return AliVEvent::kAny;
1697   }
1698   else if(kTrig=="EMCEGA")
1699   {
1700     printf("CaloTrackCorr trigger EMC Gamma\n");
1701     return AliVEvent::kEMCEGA;
1702   }
1703   else if(kTrig=="EMCEJE")
1704   {
1705     printf("CaloTrackCorr trigger EMC Jet\n");
1706     return AliVEvent::kEMCEJE;
1707   }
1708   else if(kTrig=="Central")
1709   {
1710     printf("CaloTrackCorr trigger Central\n");
1711     return (AliVEvent::kCentral  | AliVEvent::kMB);
1712   }
1713   else if(kTrig=="CentralEGA")
1714   {
1715     printf("CaloTrackCorr trigger Central+EMCEGA\n");
1716     return (AliVEvent::kCentral | AliVEvent::kEMCEGA);
1717   }
1718   else if(kTrig=="SemiCentral")
1719   {
1720     printf("CaloTrackCorr trigger SemiCentral\n");
1721     return (AliVEvent::kSemiCentral | AliVEvent::kMB);
1722   }
1723   else if(kTrig=="SemiOrCentral")
1724   {
1725     printf("CaloTrackCorr trigger SemiCentral Or Central\n");
1726     return (AliVEvent::kSemiCentral | AliVEvent::kCentral  | AliVEvent::kMB);
1727   }
1728 }
1729