PWGGA/EMCALTasks/macros/AddTaskEMCALClusterize.C

   1 // $Id$
   2
   3 AliAnalysisTaskEMCALClusterize* AddTaskEMCALClusterize(
   4                                                        TString & arrayName,
   5                                                        const Bool_t  bFillAOD   = kFALSE,
   6                                                        const Int_t   bMC        = kFALSE,
   7                                                        const Bool_t  exotic     = kTRUE,
   8                                                        const TString name       = "V1Unfold",
   9                                                        const TString trigger    = "",
  10                                                        const Bool_t  tm         = kTRUE,
  11                                                        const Int_t   minEcell   = 50,
  12                                                        const Int_t   minEseed   = 100,
  13                                                        const Int_t   maxDeltaT  = 250,
  14                                                        const Int_t   timeWindow = 1000,
  15                                                        const Int_t   minEUnf    = 15,
  16                                                        const Int_t   minFrac    = 1,
  17                                                        const Bool_t  bRecalE    = kTRUE,
  18                                                        const Bool_t  bBad       = kTRUE,
  19                                                        const Bool_t  bRecalT    = kTRUE,
  20                                                        const Bool_t  bNonLine   = kFALSE,
  21                                                        const Int_t   minCen     = -1,
  22                                                        const Int_t   maxCen     = -1,
  23                                                        const Int_t   nRowDiff   = 1,
  24                                                        const Int_t   nColDiff   = 1
  25                                                        )
  26 {
  27   // Get the pointer to the existing analysis manager via the static access method.
  28   //==============================================================================
  29   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  30   if (!mgr)
  31   {
  32     ::Error("AddTaskEMCALClusterize", "No analysis manager to connect to.");
  33     return NULL;
  34   }
  35
  36   // Check the analysis type using the event handlers connected to the analysis manager.
  37   //==============================================================================
  38   if (!mgr->GetInputEventHandler())
  39   {
  40     ::Error("AddTaskEMCALClusterize", "This clusterize requires an input event handler");
  41     return NULL;
  42   }
  43
  44   printf("Passed Settings : mc %d, exo %d, name %s, trigger %s, tm %d\n",bMC,exotic,name.Data(),trigger.Data(),tm);
  45   printf("                  Ecell %d, Eseed %d, dT %d, wT %d, minUnf %d, minFrac %d \n",minEcell, minEseed,maxDeltaT,timeWindow,minEUnf,minFrac);
  46   printf("                  recalE %d, bad %d, recalT %d, nonlin %d, minCen %d, maxCen %d, rowDiff %d, colDiff %d \n",bRecalE,bBad,bRecalT,bNonLine,minCen,maxCen,nRowDiff,nColDiff);
  47
  48   // Create name of task and AOD branch depending on different settings
  49
  50   if(name.Contains("NxN")) arrayName = Form("%dx%d_Ecell%d_Eseed%d_DT%d_WT%d",2*nRowDiff+1,2*nColDiff+1,minEcell,minEseed,maxDeltaT,timeWindow);
  51   else                     arrayName = Form(   "%s_Ecell%d_Eseed%d_DT%d_WT%d",              name.Data(),minEcell,minEseed,maxDeltaT,timeWindow);
  52
  53   if(minCen != -1 && maxCen != -1)
  54     arrayName+=Form("_Cen%d_%d",minCen,maxCen);
  55
  56   printf("Created Branch Name: \n",arrayName.Data());
  57
  58
  59   //-------------------------------------------------------
  60   // Init the task and do settings
  61   //-------------------------------------------------------
  62
  63   AliAnalysisTaskEMCALClusterize* clusterize = new AliAnalysisTaskEMCALClusterize(Form("EMCALClusterize%s",arrayName.Data()));
  64
  65   clusterize->SetAODBranchName(arrayName);
  66
  67   //clusterize->SetOCDBPath("local://$ALICE_ROOT/OCDB");
  68
  69   // Some general settings to create AOD file in case we want to keep it
  70   clusterize->SwitchOffFillAODCaloCells();
  71   clusterize->SwitchOffFillAODHeader();
  72   clusterize->FillAODFile(bFillAOD); // fill aod.root with clusters?, not really needed for analysis.
  73
  74   // Do track matching after clusterization
  75   if(tm) clusterize->SwitchOnTrackMatching();
  76   else   clusterize->SwitchOffTrackMatching();
  77
  78   //-------------------------------------------------------
  79   // Set clusterization parameters via rec param
  80   //-------------------------------------------------------
  81
  82   AliEMCALRecParam * params = clusterize->GetRecParam();
  83
  84   // Position and SS weight parameter
  85   params->SetW0(4.5);
  86
  87   // Time cuts, depend on data type (no cells time in AODs)
  88   TString sHandler((mgr->GetInputEventHandler())->ClassName());
  89   if(sHandler.Contains("AOD"))
  90   {
  91     printf("AliAnalysisTaskEMCALClusterize - Open time cuts for AODs\n");
  92     params->SetTimeCut(1e6);//Open this cut for AODs
  93     params->SetTimeMin(-1); //Open this cut for AODs
  94     params->SetTimeMax(1e6);//Open this cut for AODs
  95   }
  96   else
  97   {
  98     printf("AliAnalysisTaskEMCALClusterize - Set time cuts for ESDs\n");
  99     if(maxDeltaT > 1) params->SetTimeCut(maxDeltaT*1.e-9);
 100     else            { params->SetTimeCut(250*1.e-9); printf("default maxDeltaT = 250 ns\n"); }// Same as in reco
 101
 102     if(timeWindow > 1)
 103     {
 104       params->SetTimeMin(-1*timeWindow*1.e-9);
 105       params->SetTimeMax(timeWindow*1.e-9);
 106     }
 107     else
 108     {
 109       if(bRecalT && !bMC)
 110       {
 111         params->SetTimeMin(-250*1.e-9);
 112         params->SetTimeMax( 250*1.e-9);
 113         printf("default time window for calibrated time -250 ns < T < 250 ns\n");
 114       }
 115       else
 116       {
 117         // same as in reco, USE IF NO TIME RECALIBRATION
 118         params->SetTimeMin(425*1.e-9);
 119         params->SetTimeMax(825*1.e-9);
 120         printf("default time window 425 ns < T < 825 ns\n");
 121       }
 122     }
 123   }
 124
 125   // Energy cuts
 126   params->SetClusteringThreshold(minEseed/1.e3);
 127   params->SetMinECut            (minEcell/1.e3);
 128
 129   // Clusterizer type
 130   if(name.Contains("V2")) params->SetClusterizerFlag(AliEMCALRecParam::kClusterizerv2);
 131   if(name.Contains("V1")) params->SetClusterizerFlag(AliEMCALRecParam::kClusterizerv1);
 132   if(name.Contains("NxN"))
 133   {
 134     params->SetClusterizerFlag(AliEMCALRecParam::kClusterizerNxN);
 135     printf("Set NxN cluster size to %dx%d (row diff %d, col diff %d)\n",2*nRowDiff+1,2*nColDiff+1,nRowDiff,nColDiff);
 136     params->SetNxM(nRowDiff, nColDiff);
 137   }
 138
 139   //-------------------------------------------------------
 140   // Unfolding, 2 options :
 141   //-------------------------------------------------------
 142
 143   //    1) Just unfold existing clusters
 144   if(name.Contains("JustUnfold"))
 145     clusterize->JustUnfold(kTRUE); // if TRUE, do just unfolding, do not recluster cells
 146   else
 147     clusterize->JustUnfold(kFALSE);
 148
 149   //   2) Unfold clusters created in the clusterize (revise settings)
 150   if (name.Contains("Unfold"))
 151   {
 152     clusterize->SwitchOnCellEnergySelection();
 153     clusterize->SetCellCuts(minEUnf/1000.,minFrac/10000.);
 154     printf("AliAnalysisTaskEMCALClusterize - Cuts: min E %f, frac %f\n",minEUnf/1000.,minFrac/10000.);
 155     //clusterize->SwitchOffCellEnergySelection();
 156
 157     if(!name.Contains("Just"))
 158       params->SetUnfold(kTRUE);
 159     else
 160       params->SetUnfold(kFALSE);
 161
 162   } // unfold
 163
 164   //-------------------------------------------------------
 165   // Configure AliEMCALRecoUtils
 166   //-------------------------------------------------------
 167
 168   AliEMCALRecoUtils * reco = clusterize->GetRecoUtils();
 169   gROOT->LoadMacro("$ALICE_ROOT/PWGGA/EMCALTasks/macros/ConfigureEMCALRecoUtils.C"); // $ALICE_ROOT/PWGGA/EMCALTasks/macros
 170   ConfigureEMCALRecoUtils(reco,bMC,exotic,bNonLine,bRecalE,bBad,bRecalT);
 171
 172   //-------------------------------------------------------
 173   //Alignment matrices
 174   //-------------------------------------------------------
 175
 176   clusterize->SetImportGeometryFromFile(kTRUE); // import geometry.root file
 177
 178   if(!bMC)
 179   {
 180     clusterize->SwitchOnLoadOwnGeometryMatrices();
 181   }
 182
 183   //-------------------------------------------------------
 184   // Trigger options
 185   //-------------------------------------------------------
 186
 187   if(trigger=="EMC7")
 188   {
 189     printf("Clusterizing task trigger EMC7\n");
 190     clusterize->SelectCollisionCandidates(AliVEvent::kEMC7);
 191   }
 192   else if (trigger=="INT7")
 193   {
 194     printf("Clusterizing task trigger INT7\n");
 195     clusterize->SelectCollisionCandidates(AliVEvent::kINT7);
 196   }
 197   else if(trigger=="EMC1")
 198   {
 199     printf("Clusterizing task trigger EMC1\n");
 200     clusterize->SelectCollisionCandidates(AliVEvent::kEMC1);
 201   }
 202   else if(trigger=="MB")
 203   {
 204     printf("Clusterizing task trigger MB\n");
 205     clusterize->SelectCollisionCandidates(AliVEvent::kMB);
 206   }
 207   else if(trigger=="PHOS")
 208   {
 209     printf("Clusterizing task trigger PHOS\n");
 210     clusterize->SelectCollisionCandidates(AliVEvent::kPHI7);
 211   }
 212   else if(trigger=="PHOSPb")
 213   {
 214     printf("Clusterizing task trigger PHOSPb\n");
 215     clusterize->SelectCollisionCandidates(AliVEvent::kPHOSPb);
 216   }
 217   else if(trigger=="AnyINT")
 218   {
 219     printf("Clusterizing task trigger AnyINT\n");
 220     clusterize->SelectCollisionCandidates(AliVEvent::kAnyINT);
 221   }
 222   else if(trigger=="INT")
 223   {
 224     printf("Clusterizing task trigger AnyINT\n");
 225     clusterize->SelectCollisionCandidates(AliVEvent::kAny);
 226   }
 227   else if(trigger=="EMCEGA")
 228   {
 229     printf("Clusterizing task trigger EMC Gamma\n");
 230     clusterize->SelectCollisionCandidates(AliVEvent::kEMCEGA);
 231   }
 232   else if(trigger=="EMCEJE")
 233   {
 234     printf("Clusterizing task trigger EMC Jet\n");
 235     clusterize->SelectCollisionCandidates(AliVEvent::kEMCEJE);
 236   }
 237   else if(trigger=="Central")
 238   {
 239     printf("Clusterizing task trigger Central\n");
 240     clusterize->SelectCollisionCandidates(AliVEvent::kCentral);
 241   }
 242   else if(trigger=="SemiCentral")
 243   {
 244     printf("Clusterizing task trigger SemiCentral\n");
 245     clusterize->SelectCollisionCandidates(AliVEvent::kSemiCentral);
 246   }
 247
 248   // Set clusters branch name, make sure the analysis after this one reads this name
 249
 250   //-------------------------------------------------------
 251   // Final settings, pass to manager and set the containers
 252   //-------------------------------------------------------
 253
 254   mgr->AddTask(clusterize);
 255
 256   // Create containers for input/output
 257   AliAnalysisDataContainer *cinput1  = mgr->GetCommonInputContainer()  ;
 258   mgr->ConnectInput  (clusterize, 0,  cinput1 );
 259
 260   if(bFillAOD)
 261   {
 262     printf("AddTaskEMCALClusterize - Fill output AOD\n");
 263     AliAnalysisDataContainer *coutput1 = mgr->GetCommonOutputContainer() ;
 264     mgr->ConnectOutput (clusterize, 0, coutput1 );
 265   }
 266   return clusterize;
 267 }