Main modifications (Carlos):

- We now use AliRDHFCuts to select events.
- We can now use the new PID approach.
- FlowEvents are created inside the selector task
- We have reduced the amount of data is stored on QC and SP methods

diff --git a/PWGHF/vertexingHF/charmFlow/AddTaskFlowD2H.C b/PWGHF/vertexingHF/charmFlow/AddTaskFlowD2H.C
index 45cb0689eaab6932fcf019d3320bf6e5a18fbebc..26f915b74f8adb548bdf2843d8b2f043f8ebb64d 100644 (file)
--- a/PWGHF/vertexingHF/charmFlow/AddTaskFlowD2H.C
+++ b/PWGHF/vertexingHF/charmFlow/AddTaskFlowD2H.C
@@ -1,18 +1,19 @@
 class AliAnalysisDataContainer;
 class AliFlowEventCuts;
 class AliFlowEventTrackCuts;
+class AliFlowEventTrackSimpleCuts;
 class AliRDHFCutsD0toKpi;
 class AliRDHFCutsDStartoKpipi; 
 
-void AddTaskFlowD2H(TString fileNameCuts, TString folderName, Int_t nDmeson, Int_t minCent, Int_t maxCent, Int_t myHarmonic, 
-                   Bool_t bDoQC, Bool_t bDoSPTPC, Bool_t bDoSPVZERO, Bool_t bDoEPAlso, Int_t ptBinWidth,
-                   Double_t gapTPC, Double_t etaVZERO1, Double_t etaVZERO2, Double_t etaVZERO3, Double_t etaVZERO4,
-                   Int_t trigger, Bool_t testOnly=kFALSE ) {
+void AddTaskFlowD2H(TString fileNameCuts, TString folderName, Int_t nDmeson, Int_t myHarmonic, 
+                   Bool_t bDoQC, Bool_t bDoSPTPC, Bool_t bDoSPVZERO, Bool_t bDoEPTPC, Bool_t bDoEPVZERO, 
+                   Int_t ptBinWidth, Double_t gapTPC, Double_t etaVZERO1, Double_t etaVZERO2, Double_t etaVZERO3, Double_t etaVZERO4,
+                   Bool_t bOldApproach=kFALSE, Bool_t shrinkSP=kFALSE ) {
   TFile *filecuts = TFile::Open( fileNameCuts.Data() );
   if( (!filecuts) || ( filecuts && !filecuts->IsOpen()) ){
     AliFatal("Could not open cuts file.");
   }
-  filecuts->ls();
+
   TString fileName = AliAnalysisManager::GetCommonFileName();
   fileName.ReplaceAll(".root","");
 
@@ -20,7 +21,6 @@ void AddTaskFlowD2H(TString fileNameCuts, TString folderName, Int_t nDmeson, Int
   AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
 
   TString thecuts = folderName;
-  
   TString sgn = DMesonName( nDmeson ) + Form("w%d",ptBinWidth);
 
   //**********************************************************************
@@ -51,117 +51,110 @@ void AddTaskFlowD2H(TString fileNameCuts, TString folderName, Int_t nDmeson, Int
   // POI FILTER CUTS
   AliFlowTrackSimpleCuts *filterPOIQC[50]; // MASS BANDS
   AliFlowTrackSimpleCuts *filterPOISP[50][2]; // MASS BANDS || ETA || SUBEVENT GAP
-  int myMassBands = NumberOfMassBins( nDmeson );
-  if(testOnly)
-    myMassBands = 1;
+  int myMassBands = MassBands( nDmeson, bOldApproach );
   for(int mb=0; mb!=myMassBands; ++mb) {
     filterPOISP[mb][0] = new AliFlowTrackSimpleCuts( Form("FilterPOISP_MB%d_ETANEG",mb) );
     filterPOISP[mb][0]->SetEtaMin( -0.8 );
     filterPOISP[mb][0]->SetEtaMax( 0. );
-    filterPOISP[mb][0]->SetMassMin( LowMassBin(nDmeson,mb) );
-    filterPOISP[mb][0]->SetMassMax( LowMassBin(nDmeson,mb+1) );
+    filterPOISP[mb][0]->SetMassMin( MassBandLowEdge(nDmeson,mb,bOldApproach) );
+    filterPOISP[mb][0]->SetMassMax( MassBandLowEdge(nDmeson,mb+1,bOldApproach) );
     filterPOISP[mb][1] = new AliFlowTrackSimpleCuts( Form("FilterPOISP_MB%d_ETAPOS",mb) );
     filterPOISP[mb][1]->SetEtaMin( 0. );
     filterPOISP[mb][1]->SetEtaMax( +0.8 );
-    filterPOISP[mb][1]->SetMassMin( LowMassBin(nDmeson,mb) );
-    filterPOISP[mb][1]->SetMassMax( LowMassBin(nDmeson,mb+1) );
+    filterPOISP[mb][1]->SetMassMin( MassBandLowEdge(nDmeson,mb,bOldApproach) );
+    filterPOISP[mb][1]->SetMassMax( MassBandLowEdge(nDmeson,mb+1,bOldApproach) );
     filterPOIQC[mb] = new AliFlowTrackSimpleCuts( Form("FilterPOIQC_MB%d",mb) );
     filterPOIQC[mb]->SetEtaMin( -0.8 );
     filterPOIQC[mb]->SetEtaMax( +0.8 );
-    filterPOIQC[mb]->SetMassMin( LowMassBin(nDmeson,mb) );
-    filterPOIQC[mb]->SetMassMax( LowMassBin(nDmeson,mb+1) );
+    filterPOIQC[mb]->SetMassMin( MassBandLowEdge(nDmeson,mb,bOldApproach) );
+    filterPOIQC[mb]->SetMassMax( MassBandLowEdge(nDmeson,mb+1,bOldApproach) );
   }
 
-  int minCC = minCent;
-  int maxCC = maxCent;
-  TString ccName = Form("cc%d%d",minCC,maxCC);
-  // * EVENT CUTS ******************************************************
-  AliFlowEventCuts* cutsEvent = new AliFlowEventCuts( Form("EventCuts_%s",ccName.Data()) );
-  cutsEvent->SetCentralityPercentileRange(minCC,maxCC);
-  cutsEvent->SetCentralityPercentileMethod(AliFlowEventCuts::kV0);
-  cutsEvent->SetNContributorsRange(2);
-  cutsEvent->SetPrimaryVertexZrange(-9.,9.);
-  cutsEvent->SetQA(kTRUE);
-  cutsEvent->SetRefMultMethod(AliESDtrackCuts::kTrackletsITSTPC);
   // * DMESON SELECTOR *************************************************
   AliAnalysisTaskFlowD2H *taskSel;
   switch (nDmeson) {
   case ( AliRDHFCuts::kD0toKpiCuts ):
-    AliRDHFCutsD0toKpi *myCutsD0;
-    myCutsD0 = (AliRDHFCutsD0toKpi*)filecuts->Get("D0toKpiCuts");
+    AliRDHFCutsD0toKpi *myCutsD0 = (AliRDHFCutsD0toKpi*)filecuts->Get("D0toKpiCuts");
     if(!myCutsD0) {
       AliFatal("Problems reaching D0toKpiCuts");
     }
-    taskSel = new AliAnalysisTaskFlowD2H( Form("TaskD0Selector_%s",ccName.Data()), 
-                                         cutsEvent, myCutsD0, nDmeson );
+    taskSel = new AliAnalysisTaskFlowD2H( Form("TaskD0Selector_%s",thecuts.Data()), 
+                                         cutsRFPTPC, cutsRFPVZE, myCutsD0, nDmeson );
     break;
   case ( AliRDHFCuts::kDstarCuts ):
-    AliRDHFCutsDStartoKpipi *myCutsDStar;
-    myCutsDStar = (AliRDHFCutsDStartoKpipi*)filecuts->Get("DStartoKpipiCuts");
+    AliRDHFCutsDStartoKpipi *myCutsDStar = (AliRDHFCutsDStartoKpipi*)filecuts->Get("DStartoKpipiCuts");
     if(!myCutsDStar) {
       AliFatal("Problems reaching DStarToKpipiCuts");
     }
-    taskSel = new AliAnalysisTaskFlowD2H( Form("TaskDStarSelector_%s",ccName.Data()),
-                                         cutsEvent, myCutsDStar, nDmeson);
+    taskSel = new AliAnalysisTaskFlowD2H( Form("TaskDStarSelector_%s",thecuts.Data()),
+                                         cutsRFPTPC, cutsRFPVZE, myCutsDStar, nDmeson);
     break;
   case (AliRDHFCuts::kDplusCuts):
-    AliRDHFCutsDplustoKpipi *myCutsDplus;
-    myCutsDplus = (AliRDHFCutsDplustoKpipi*)filecuts->Get("AnalysisCuts");
+    AliRDHFCutsDplustoKpipi *myCutsDplus = (AliRDHFCutsDplustoKpipi*)filecuts->Get("AnalysisCuts");
     if(!myCutsDplus) {
       AliFatal("Problems reaching AnalysisCuts");
     }
-    taskSel = new AliAnalysisTaskFlowD2H( Form("TaskDplusSelector_%s",ccName.Data()), 
-                                         cutsEvent, myCutsDplus, nDmeson );
+    taskSel = new AliAnalysisTaskFlowD2H( Form("TaskDplusSelector_%s",thecuts.Data()), 
+                                         cutsRFPTPC, cutsRFPVZE, myCutsDplus, nDmeson );
     break;
   }
-  taskSel->SelectCollisionCandidates(trigger);
+  taskSel->SetCommonConstants( MassBins(nDmeson), MinMass(nDmeson), MaxMass(nDmeson), ptBinWidth );
+
+  //taskSel->SelectCollisionCandidates(trigger);
   //taskSel->SetDebug();
-  AliAnalysisDataContainer *coutHist = mgr->CreateContainer( Form("%sSelector_%s",sgn.Data(),ccName.Data()),
+  AliAnalysisDataContainer *coutHist = mgr->CreateContainer( Form("%sSelector_%s",sgn.Data(),thecuts.Data()),
                                                             TList::Class(),AliAnalysisManager::kOutputContainer,
-                                                            Form("%s.root:FlowD2H_%s_%s",fileName.Data(),ccName.Data(),thecuts.Data()) );
-  AliAnalysisDataContainer *coutArr = mgr->CreateContainer( Form("TaskSelectorCandidates_%s_%s",ccName.Data(),sgn.Data()),
-                                                           TObjArray::Class(),AliAnalysisManager::kExchangeContainer);
+                                                            Form("%s.root:FlowD2H_%s",fileName.Data(),thecuts.Data()) );
+  AliAnalysisDataContainer *exc_TPC = mgr->CreateContainer( Form("TPCEventWithCandidates_%s_%s",sgn.Data(),thecuts.Data()),
+                                                           AliFlowEventSimple::Class(),
+                                                           AliAnalysisManager::kExchangeContainer );
+  AliAnalysisDataContainer *exc_VZE = mgr->CreateContainer( Form("VZEEventWithCandidates_%s_%s",sgn.Data(),thecuts.Data()),
+                                                           AliFlowEventSimple::Class(),
+                                                           AliAnalysisManager::kExchangeContainer );
   mgr->AddTask(taskSel);
   mgr->ConnectOutput(taskSel,1,coutHist);
-  mgr->ConnectOutput(taskSel,2,coutArr);
+  mgr->ConnectOutput(taskSel,2,exc_TPC);
+  mgr->ConnectOutput(taskSel,3,exc_VZE);
   mgr->ConnectInput (taskSel,0,cinput1);
-  // * RAW FLOWEVENT TPC *************************************************
-  AliAnalysisDataContainer *exc_TPC = MakeFlowEvent("TPC", ccName.Data(), fileName.Data(), thecuts.Data(), ptBinWidth, cinput1,
-                                                   coutArr, cutsEvent, cutsRFPTPC, cutsPOI, true, nDmeson, 1.0);
-  // * RAW FLOWEVENT VZERO ***********************************************
-  AliAnalysisDataContainer *exc_VZE = MakeFlowEvent("VZE", ccName.Data(), fileName.Data(), thecuts.Data(), ptBinWidth, cinput1,
-                                                   coutArr, cutsEvent, cutsRFPVZE, cutsPOI, false, nDmeson, 5.0);
+
   // * HANGING ANALYSIS TASKS ********************************************
   int harm = myHarmonic;
   for(int mb=0; mb!=myMassBands; ++mb) {
     if(bDoQC) {
-      AddQCmethod( Form("%sQCTPCMB%d",sgn.Data(),mb), ccName.Data(), fileName.Data(), thecuts.Data(), harm, exc_TPC, filterPOIQC[mb]);
+      AddQCmethod( Form("%sQCTPCMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), harm, exc_TPC, filterPOIQC[mb]);
     }
     if(bDoSPVZERO) {
-      AddSPmethod( Form("%sSPVZEMB%d",sgn.Data(),mb), ccName.Data(), fileName.Data(), thecuts.Data(), etaVZERO1, etaVZERO2, etaVZERO3, etaVZERO4,
-                  "Qa", harm, exc_VZE, 0, filterPOIQC[mb], NULL, bDoEPAlso );
-      AddSPmethod( Form("%sSPVZEMB%d",sgn.Data(),mb), ccName.Data(), fileName.Data(), thecuts.Data(), etaVZERO1, etaVZERO2, etaVZERO3, etaVZERO4,
-                  "Qb", harm, exc_VZE, 0, filterPOIQC[mb], NULL, bDoEPAlso );
+      AddSPmethod( Form("%sSPVZEMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), etaVZERO1, etaVZERO2, etaVZERO3, etaVZERO4,
+                  "Qa", harm, exc_VZE, 0, filterPOIQC[mb], NULL, false, shrinkSP );
+      AddSPmethod( Form("%sSPVZEMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), etaVZERO1, etaVZERO2, etaVZERO3, etaVZERO4,
+                  "Qb", harm, exc_VZE, 0, filterPOIQC[mb], NULL, false, shrinkSP );
+    }
+    if(bDoEPVZERO) {
+      AddEPmethod( Form("%sEPVZEMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), etaVZERO1, etaVZERO2, etaVZERO3, etaVZERO4,
+                  "QaQb", harm, exc_VZE, 0, filterPOIQC[mb], NULL, true, shrinkSP );
     }
     if(bDoSPTPC) {
       for(int eg=0; eg!=2; ++eg) {
-       AddSPmethod( Form("%sSPTPCMB%d",sgn.Data(),mb), ccName.Data(), fileName.Data(), thecuts.Data(), -0.8, -gapTPC*eg, +gapTPC*eg, +0.8,
-                    "Qa", harm, exc_TPC, eg, filterPOISP[mb][1], NULL, bDoEPAlso );
-       AddSPmethod( Form("%sSPTPCMB%d",sgn.Data(),mb), ccName.Data(), fileName.Data(), thecuts.Data(), -0.8, -gapTPC*eg, +gapTPC*eg, +0.8,
-                    "Qb", harm, exc_TPC, eg, filterPOISP[mb][0], NULL, bDoEPAlso );
+       AddSPmethod( Form("%sSPTPCMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), -0.8, -gapTPC*eg, +gapTPC*eg, +0.8,
+                    "Qa", harm, exc_TPC, eg, filterPOISP[mb][1], NULL, false, shrinkSP );
+       AddSPmethod( Form("%sSPTPCMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), -0.8, -gapTPC*eg, +gapTPC*eg, +0.8,
+                    "Qb", harm, exc_TPC, eg, filterPOISP[mb][0], NULL, false, shrinkSP );
       }
     }
+    if(bDoEPTPC) {
+      AddSPmethod( Form("%sEPTPCMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), -0.8, -0.0, +0.0, +0.8,
+                  "QaQb", harm, exc_TPC, 0, filterPOIQC[mb][0], NULL, true, shrinkSP );
+    }
   }
 }
 
-void AddSPmethod(char *name, char *ccName, char *fileName, char *thecuts,
+void AddSPmethod(char *name, char *fileName, char *thecuts,
                 double minEtaA, double maxEtaA, double minEtaB, double maxEtaB,
                 char *Qvector, int harmonic, AliAnalysisDataContainer *flowEvent, int eg,
                 AliFlowTrackSimpleCuts *cutsPOI=NULL, AliFlowTrackSimpleCuts *cutsRFP=NULL,
-                bool bEP ) {
-  TString myFolder = Form("%sv%d_%s",ccName,harmonic,thecuts);
-  TString myNameSP = Form("%s%sSPv%d%sGAP%d",name,ccName,harmonic,Qvector,eg);
-  TString myNameEP = Form("%s%sEPv%d%sGAP%d",name,ccName,harmonic,Qvector,eg);
+                bool bEP, bool shrink=false ) {
+  TString myFolder = Form("v%d_%s",harmonic,thecuts);
+  TString myNameSP = Form("%sSPv%d%sGAP%d_%s",name,harmonic,Qvector,eg,thecuts);
   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
   AliAnalysisDataContainer *flowEvent2 = mgr->CreateContainer( Form("Filter_%s", myNameSP.Data()),
                                                               AliFlowEventSimple::Class(),
@@ -172,7 +165,6 @@ void AddSPmethod(char *name, char *ccName, char *fileName, char *thecuts,
   mgr->AddTask(tskFilter);
   mgr->ConnectInput( tskFilter,0,flowEvent);
   mgr->ConnectOutput(tskFilter,1,flowEvent2);
-  //SP
   AliAnalysisDataContainer *outSP = mgr->CreateContainer( myNameSP.Data(),
                                                          TList::Class(),AliAnalysisManager::kOutputContainer,
                                                          Form("%s.root:FlowD2H_SP_%s",fileName,myFolder.Data()) );
@@ -181,32 +173,18 @@ void AddSPmethod(char *name, char *ccName, char *fileName, char *thecuts,
   tskSP->SetApplyCorrectionForNUA(kTRUE);
   tskSP->SetHarmonic(harmonic);
   tskSP->SetTotalQvector(Qvector);
+  if(bEP) tskSP->SetBehaveAsEP();
+  if(shrink) tskSP->SetBookOnlyBasicCCH(kTRUE);
   mgr->AddTask(tskSP);
   mgr->ConnectInput( tskSP,0,flowEvent2);
   mgr->ConnectOutput(tskSP,1,outSP);
-
-  //EP
-  if(bEP) {
-    AliAnalysisDataContainer *outEP = mgr->CreateContainer( myNameEP.Data(),
-                                                           TList::Class(),AliAnalysisManager::kOutputContainer,
-                                                           Form("%s.root:FlowD2H_EP_%s",fileName,myFolder.Data()) );
-    AliAnalysisTaskScalarProduct *tskEP = new AliAnalysisTaskScalarProduct( Form("TaskEventsPlane_%s",
-                                                                                myNameEP.Data()),kFALSE);
-    tskEP->SetApplyCorrectionForNUA(kTRUE);
-    tskEP->SetHarmonic(harmonic);
-    tskEP->SetTotalQvector(Qvector);
-    tskEP->SetBehaveAsEP();
-    mgr->AddTask(tskEP);
-    mgr->ConnectInput( tskEP,0,flowEvent2);
-    mgr->ConnectOutput(tskEP,1,outEP);
-  }
 }
 
-void AddQCmethod(char *name, char *ccName, char *fileName, char *thecuts,
+void AddQCmethod(char *name, char *fileName, char *thecuts,
                 int harmonic, AliAnalysisDataContainer *flowEvent,
                 AliFlowTrackSimpleCuts *cutsPOI=NULL, AliFlowTrackSimpleCuts *cutsRFP=NULL) {
-  TString myFolder = Form("%sv%d_%s",ccName,harmonic,thecuts);
-  TString myName = Form("%s%sv%d",name,ccName,harmonic);
+  TString myFolder = Form("v%d_%s",harmonic,thecuts);
+  TString myName = Form("%sv%d_%s",name,harmonic,thecuts);
   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
   AliAnalysisDataContainer *flowEvent2 = mgr->CreateContainer( Form("Filter_%s", myName.Data()),
                                                               AliFlowEventSimple::Class(),
@@ -223,71 +201,58 @@ void AddQCmethod(char *name, char *ccName, char *fileName, char *thecuts,
                                                                         myName.Data()),kFALSE);
   tskQC->SetApplyCorrectionForNUA(kTRUE);
   tskQC->SetHarmonic(harmonic);
+  tskQC->SetBookOnlyBasicCCH(kTRUE);
   mgr->AddTask(tskQC);
   mgr->ConnectInput( tskQC,0,flowEvent2);
   mgr->ConnectOutput(tskQC,1,outQC);
 }
 
-AliAnalysisDataContainer* MakeFlowEvent(char* RFPName, char* ccName, char *fileName, char *thecuts, Int_t ptbins,
-                                       AliAnalysisDataContainer *input, 
-                                       AliAnalysisDataContainer *array,
-                                       AliFlowEventCuts *eventCuts,
-                                       AliFlowTrackCuts *rfpCuts, AliFlowTrackCuts *poiCuts, 
-                                       bool turnOnQA, int nDmeson, double etaMax=1.0) {
-  TString meson = DMesonName(nDmeson);
-  TString myName = Form("%sFlowEventQA%s%s",meson.Data(),ccName,RFPName);
-  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
-  AliAnalysisDataContainer *exc = mgr->CreateContainer( Form("exchange_%s", myName.Data()),
-                                                       AliFlowEventSimple::Class(), 
-                                                       AliAnalysisManager::kExchangeContainer );
-  AliAnalysisDataContainer *out = mgr->CreateContainer( myName.Data(),
-                                                       TList::Class(),AliAnalysisManager::kOutputContainer,
-                                                       Form("%s.root:FlowD2H_%s_%s",fileName,ccName,thecuts) );
-  AliAnalysisTaskFlowEvent *fe = new AliAnalysisTaskFlowEvent( Form("Task_%s",myName.Data()),"", kFALSE, 666, kTRUE );
-  fe->SetCutsEvent(eventCuts);
-  fe->SetCutsRP(rfpCuts);
-  fe->SetCutsPOI(poiCuts);
-  fe->SetQAOn(turnOnQA);
-  fe->SelectCollisionCandidates(AliVEvent::kCentral|AliVEvent::kSemiCentral|AliVEvent::kMB);
-
-  fe->SetNbinsEta(20); fe->SetEtaMin(-etaMax); fe->SetEtaMax(+etaMax);
-
-  int bins = NumberOfMassBins(nDmeson);
-  fe->SetNbinsMass( bins );
-  fe->SetMassMin( LowMassBin(nDmeson,0) );
-  fe->SetMassMax( LowMassBin(nDmeson,bins) );
+int MassBands( int nDmeson, bool bOldApproach=false ) {
+  switch (nDmeson) {
+  case ( AliRDHFCuts::kD0toKpiCuts ):
+    if(bOldApproach) return 5;
+    else return 26;
+  case ( AliRDHFCuts::kDstarCuts ):
+    return 25;
+  }
+}
 
-  fe->SetNbinsPt(24/ptbins); fe->SetPtMin(0); fe->SetPtMax(24);
-  fe->SetNbinsMult(2); fe->SetMultMin(2); fe->SetMultMax(10);
-  fe->SetNbinsPhi(20); fe->SetPhiMin(0); fe->SetPhiMax(TMath::TwoPi());
-  fe->SetNbinsQ(10); fe->SetQMin( 0 ); fe->SetQMax( 3 );
+double MassBandLowEdge( int nDmeson, int mb, bool bOldApproach=false ) {
+  switch (nDmeson) {
+  case ( AliRDHFCuts::kD0toKpiCuts ): // 2 + 20 + 4
+    double lowEdgeMinimal[5+1] = {1.75,1.80,1.83,1.90,1.93,2.03};
+    double lowEdge[26+1] = { 1.66, 1.71, 1.76, 1.77, 1.78, 1.79, 1.80, 1.81, 1.82, 1.83,
+                            1.84, 1.85, 1.86, 1.87, 1.88, 1.89, 1.90, 1.91, 1.92, 1.93,
+                            1.94, 1.95, 1.96, 2.01, 2.06, 2.11, 2.16 };
+    if(bOldApproach) return lowEdgeMinimal[mb];
+    else return lowEdge[mb];
+  case ( AliRDHFCuts::kDstarCuts ): // symmetric mass bands (TOTUNE)
+    int bins = MassBands( nDmeson );
+    double min = 0.138;
+    double max = 0.158;
+    return min+mb*(max-min)/bins;
+  }
+}
 
-  mgr->AddTask(fe);
-  mgr->ConnectInput (fe,0,input);
-  mgr->ConnectInput (fe,1,array);
-  mgr->ConnectOutput(fe,1,exc);
-  mgr->ConnectOutput(fe,2,out);
-  return exc;
+double MinMass( int nDmeson ) {
+  switch (nDmeson) {
+  case ( AliRDHFCuts::kD0toKpiCuts ):
+    return 1.66;
+  case ( AliRDHFCuts::kDstarCuts ):
+    return 1.38;
+  }
 }
 
-double LowMassBin( int nDmeson, int mb) {
-  double min,max;
-  int bins = NumberOfMassBins( nDmeson );
-  if(mb>bins) return 0.0;
+double MaxMass( int nDmeson ) {
   switch (nDmeson) {
   case ( AliRDHFCuts::kD0toKpiCuts ):
-    min = 1.700;
-    max = 2.200;
-    break;
+    return 2.16;
   case ( AliRDHFCuts::kDstarCuts ):
-    min = 0.138;
-    max = 0.158;
-    break;
+    return 1.58;
   }
-  return min+mb*(max-min)/bins;
 }
 
-int NumberOfMassBins( int nDmeson ) {
+int MassBins( int nDmeson ) {
   switch (nDmeson) {
   case ( AliRDHFCuts::kD0toKpiCuts ):
     return 50;

diff --git a/PWGHF/vertexingHF/charmFlow/AliAnalysisTaskFlowD2H.cxx b/PWGHF/vertexingHF/charmFlow/AliAnalysisTaskFlowD2H.cxx
index 0cd2e46f4a08bf6c27e441d9db0c8d7cb79a0ade..ab03bdf9fdee7742b864eb73bd66bd8212083f62 100644 (file)
--- a/PWGHF/vertexingHF/charmFlow/AliAnalysisTaskFlowD2H.cxx
+++ b/PWGHF/vertexingHF/charmFlow/AliAnalysisTaskFlowD2H.cxx
@@ -15,7 +15,7 @@
 
 //==============================================================================
 // FlowD2H main task:
-// >> Select candidates and passes the array to the daughter tasks.
+// >> Select candidates and passes flowevents to the daughter tasks.
 // >> The POIcuts are polymorphic based on the AliRDHFCuts class allowing the 
 //    use of all charmed candidates reconstructed in the central barrel.
 // Author: Carlos Perez (cperez@cern.ch)
@@ -46,7 +46,9 @@
 
 #include "TMath.h"
 
-#include "AliFlowEventCuts.h"
+#include "AliFlowCommonConstants.h"
+#include "AliFlowEvent.h"
+#include "AliFlowTrackCuts.h"
 #include "AliFlowCandidateTrack.h"
 
 #include "TObjArray.h"
@@ -59,29 +61,42 @@ ClassImp(AliAnalysisTaskFlowD2H)
 
 //_____________________________________________________________________________
 AliAnalysisTaskFlowD2H::AliAnalysisTaskFlowD2H() :
-AliAnalysisTaskSE(), fEventCuts(NULL), fCutsPOI(NULL), fSource(0),
-  fDebugV2(kFALSE), fHList(NULL), fEvent(NULL), fCandidates(NULL)
+  AliAnalysisTaskSE(), fTPCEvent(NULL), fVZEEvent(NULL), 
+  fCutsTPC(NULL), fCutsVZE(NULL), fNoPOIs(NULL), fCutsPOI(NULL),
+  fSource(0), fDebugV2(kFALSE), fMassBins(0), fMinMass(0.),
+  fMaxMass(0.), fPtBinWidth(0), fHList(NULL), fEvent(NULL), 
+  fCC(NULL), fRFPMTPC(NULL), fRFPPhiTPC(NULL), fCandidates(NULL)
 {
 // Default constructor
 }
 
 //_____________________________________________________________________________
-AliAnalysisTaskFlowD2H::AliAnalysisTaskFlowD2H(const char *name,
-                                              AliFlowEventCuts *eventCuts,
+AliAnalysisTaskFlowD2H::AliAnalysisTaskFlowD2H(const char *name,       
+                                              AliFlowTrackCuts *cutsTPC,
+                                              AliFlowTrackCuts *cutsVZE,
                                               AliRDHFCuts *cutsPOIs,
                                               Int_t specie) :
-  AliAnalysisTaskSE(name), fEventCuts(eventCuts), fCutsPOI(cutsPOIs),
-  fSource(specie), fDebugV2(kFALSE), fHList(NULL), fEvent(NULL), fCandidates(NULL)
+  AliAnalysisTaskSE(name), fTPCEvent(NULL), fVZEEvent(NULL), 
+  fCutsTPC(cutsTPC), fCutsVZE(cutsVZE), fNoPOIs(NULL), fCutsPOI(cutsPOIs),
+  fSource(specie), fDebugV2(kFALSE), fMassBins(0), fMinMass(0.),
+  fMaxMass(0.), fPtBinWidth(0), fHList(NULL), fEvent(NULL),
+  fCC(NULL), fRFPMTPC(NULL), fRFPPhiTPC(NULL), fCandidates(NULL)
 {
 // Standard constructor
   DefineInput( 0,TChain::Class());
   DefineOutput(1,TList::Class());
-  DefineOutput(2,TObjArray::Class());
+  DefineOutput(2,AliFlowEventSimple::Class());
+  DefineOutput(3,AliFlowEventSimple::Class());
 }
 
 //_____________________________________________________________________________
 AliAnalysisTaskFlowD2H::~AliAnalysisTaskFlowD2H(){
   // delete objects
+  if(fTPCEvent) delete fTPCEvent;
+  if(fVZEEvent) delete fVZEEvent;
+  if(fCutsTPC) delete fCutsTPC;
+  if(fCutsVZE) delete fCutsVZE;
+  if(fNoPOIs) delete fNoPOIs;
   if(fCutsPOI) delete fCutsPOI;
   if(fHList) delete fHList;
   if(fCandidates) delete fCandidates;
@@ -99,12 +114,46 @@ void AliAnalysisTaskFlowD2H::UserCreateOutputObjects(){
   fEvent->GetXaxis()->SetBinLabel(2,"SELECTED");
   fEvent->GetXaxis()->SetBinLabel(3,"DELTA AOD REACHED");
   fHList->Add( fEvent );
+  fCC = new TH1D("CentralityClass","Centrality Class",50,0,100);
+  fHList->Add( fCC );
+  fRFPMTPC = new TH1D("RFPMultiplicityTPC","RFP Multiplicity TPC",300,0,3000);
+  fHList->Add( fRFPMTPC );
+  fRFPPhiTPC = new TH1D("RFPPhiTPC","RFP Phi TPC",180,0,TMath::TwoPi());
+  fHList->Add( fRFPPhiTPC );
 
-  fCandidates = new TObjArray(300);
+  fCandidates = new TObjArray(100);
   fCandidates->SetOwner();
 
+  AliFlowCommonConstants* cc = AliFlowCommonConstants::GetMaster();
+  cc->SetNbinsMult(1);
+  cc->SetNbinsPt(24/fPtBinWidth);
+  cc->SetNbinsPhi(1);
+  cc->SetNbinsEta(15);
+  cc->SetNbinsQ(1);
+  cc->SetNbinsMass( fMassBins );
+  cc->SetMultMin(1);
+  cc->SetMultMax(2);
+  cc->SetPtMin(0);
+  cc->SetPtMax(24);
+  cc->SetPhiMin(0);
+  cc->SetPhiMax(TMath::TwoPi());
+  cc->SetEtaMin(-3.9);
+  cc->SetEtaMax(+5.1);
+  cc->SetQMin(0);
+  cc->SetQMax(1);
+  cc->SetMassMin( fMinMass );
+  cc->SetMassMax( fMaxMass );
+
+  fTPCEvent = new AliFlowEvent(3000);
+  fVZEEvent = new AliFlowEvent(170);
+
+  fNoPOIs = new AliFlowTrackCuts( "noPOIs" );
+  fNoPOIs->SetParamType(AliFlowTrackCuts::kGlobal);
+  fNoPOIs->SetPtRange(+1,-1);
+
   PostData(1,fHList);
-  PostData(2,fCandidates);
+  PostData(2,fTPCEvent);
+  PostData(3,fVZEEvent);
 }
 //_____________________________________________________________________________
 void AliAnalysisTaskFlowD2H::UserExec(Option_t *)
@@ -115,9 +164,29 @@ void AliAnalysisTaskFlowD2H::UserExec(Option_t *)
   if(!fAOD) return;
   fEvent->Fill( 0 );
 
-  if(!fEventCuts->IsSelected(fAOD)) return;
+  // floweventcuts::isselected() and alirdhfcuts::iseventselected() cut on the same 
+  // values in the same way BUT the latter also loads the PIDresponse object from the 
+  // event header!!! 
+  //  if(!fEventCuts->IsSelected(fAOD)) return;
+  if(!fCutsPOI->IsEventSelected(fAOD)) return;
   fEvent->Fill( 1 );
 
+  fCC->Fill( fCutsPOI->GetCentrality(fAOD) );
+
+  fCutsTPC->SetEvent( fAOD, MCEvent() );
+  fCutsVZE->SetEvent( fAOD, MCEvent() );
+  fNoPOIs->SetEvent( fAOD, MCEvent() );
+  fTPCEvent->Fill( fCutsTPC, fNoPOIs );
+  fVZEEvent->Fill( fCutsVZE, fNoPOIs );
+
+  Int_t rfps = fTPCEvent->GetNumberOfRPs();
+  fRFPMTPC->Fill( rfps );
+  for(int iRPs=0; iRPs!=rfps; ++iRPs ) {
+    AliFlowTrack *iRP = dynamic_cast<AliFlowTrack*>(fTPCEvent->GetTrack( iRPs ));
+    if (!iRP) continue;
+    fRFPPhiTPC->Fill( iRP->Phi() );
+  }
+
   if (fDebugV2) printf("Event selected\n");
   fCandidates->SetLast(-1); // resets the array
 
@@ -130,10 +199,36 @@ void AliAnalysisTaskFlowD2H::UserExec(Option_t *)
       FillDplustoKpipi(fAOD); break;
   }
 
-  if (fDebugV2) printf("Candidates inserted: %d\n", fCandidates->GetEntriesFast() );
-  PostData(1,fHList);
-  PostData(2,fCandidates);
+  if(fDebugV2) printf("TPCevent %d | VZEevent %d\n", fTPCEvent->NumberOfTracks(), fVZEEvent->NumberOfTracks() );
+  //inject candidates
+  if (fDebugV2)  printf("I received %d candidates\n",fCandidates->GetEntriesFast());
+  for(int iCand=0; iCand!=fCandidates->GetEntriesFast(); ++iCand ) {
+    AliFlowCandidateTrack *cand = dynamic_cast<AliFlowCandidateTrack*>(fCandidates->At(iCand));
+    if (!cand) continue;
+    if (fDebugV2) printf(" >Checking at candidate %d with %d daughters: mass %f\n",iCand,cand->GetNDaughters(),cand->Mass());
+    for(int iDau=0; iDau!=cand->GetNDaughters(); ++iDau) {
+      if(fDebugV2) printf("  >Daughter %d with fID %d", iDau, cand->GetIDDaughter(iDau));
+      for(int iRPs=0; iRPs!=fTPCEvent->NumberOfTracks(); ++iRPs ) {
+       AliFlowTrack *iRP = dynamic_cast<AliFlowTrack*>(fTPCEvent->GetTrack( iRPs ));
+       if (!iRP) continue;
+       if( !iRP->InRPSelection() ) continue;
+       if( cand->GetIDDaughter(iDau) == iRP->GetID() ) {
+         if(fDebugV2) printf(" was in RP set");
+         iRP->SetForRPSelection(kFALSE);
+         fTPCEvent->SetNumberOfRPs( fTPCEvent->GetNumberOfRPs() -1 );
+       }
+      }
+      if(fDebugV2) printf("\n");
+    }
+    cand->SetForPOISelection(kTRUE);
+    fTPCEvent->InsertTrack( ((AliFlowTrack*) cand) );
+    fVZEEvent->InsertTrack( ((AliFlowTrack*) cand) );
+  }
+  if(fDebugV2) printf("TPCevent %d | VZEevent %d\n", fTPCEvent->NumberOfTracks(), fVZEEvent->NumberOfTracks() );
 
+  PostData(1,fHList);
+  PostData(2,fTPCEvent);
+  PostData(3,fVZEEvent);
 }
 //______________________________________________________________________________
 void AliAnalysisTaskFlowD2H::FillD0toKpi(const AliAODEvent *theAOD)
@@ -270,3 +365,10 @@ void AliAnalysisTaskFlowD2H::MakeTrack( Double_t mass, Double_t pt, Double_t phi
   }
   return;
 }
+
+void AliAnalysisTaskFlowD2H::SetCommonConstants(Int_t massBins, Double_t minMass, Double_t maxMass, Int_t ptWidth) {
+  fMassBins = massBins;
+  fMinMass = minMass;
+  fMaxMass = maxMass;
+  fPtBinWidth = ptWidth;
+}

diff --git a/PWGHF/vertexingHF/charmFlow/AliAnalysisTaskFlowD2H.h b/PWGHF/vertexingHF/charmFlow/AliAnalysisTaskFlowD2H.h
index cd17f2263f3994ca6af4d851339052c13be2df57..d9b77de82f6634f63ef6d7f4c5998d70ab4b85b2 100644 (file)
--- a/PWGHF/vertexingHF/charmFlow/AliAnalysisTaskFlowD2H.h
+++ b/PWGHF/vertexingHF/charmFlow/AliAnalysisTaskFlowD2H.h
@@ -20,7 +20,9 @@ class AliAODEvent;
 class AliRDHFCuts;
 class AliRDHFCutsD0toKpi;
 class AliFlowEventCuts;
+class AliFlowEvent;
 class AliFlowCandidateTrack;
+class AliFlowTrackCuts;
 class TList;
 class TH1D;
 
@@ -28,13 +30,15 @@ class AliAnalysisTaskFlowD2H : public AliAnalysisTaskSE {
   public:
     AliAnalysisTaskFlowD2H();
     AliAnalysisTaskFlowD2H( const Char_t *name, 
-                           AliFlowEventCuts *cutsEvent,
+                           AliFlowTrackCuts *cutsTPC,
+                           AliFlowTrackCuts *cutsVZE,
                            AliRDHFCuts *cutsPOIs, 
                            Int_t specie );
     void SetDebug() {fDebugV2 = true;}
     virtual ~AliAnalysisTaskFlowD2H();
     virtual void UserCreateOutputObjects();
     virtual void UserExec(Option_t *);
+    void SetCommonConstants(Int_t massBins, Double_t minMass, Double_t maxMass, Int_t ptWidth);
 
   private:
     AliAnalysisTaskFlowD2H(const AliAnalysisTaskFlowD2H& analysisTask);
@@ -51,17 +55,31 @@ class AliAnalysisTaskFlowD2H : public AliAnalysisTaskSE {
     void MakeTrack( Double_t mass, Double_t pt,
                    Double_t phi, Double_t eta,
                    Int_t nDaughters, const Int_t *iID );
-    AliFlowEventCuts *fEventCuts;
+
+    AliFlowEvent *fTPCEvent;
+    AliFlowEvent *fVZEEvent;
+    AliFlowTrackCuts *fCutsTPC;
+    AliFlowTrackCuts *fCutsVZE;
+    AliFlowTrackCuts *fNoPOIs;
+
     AliRDHFCuts *fCutsPOI; // cuts for POIs
     Int_t  fSource; // AliRDHFCuts::ESele
     Bool_t fDebugV2; // fully talkative task
 
+    Int_t fMassBins; // configures mass bins for the analysis
+    Double_t fMinMass; // configures mass range for the analysis
+    Double_t fMaxMass; // configures mass range for the analysis
+    Int_t fPtBinWidth; // configures pt bin width for the analysis
+
     TList *fHList; // List for histos
-    TH1D  *fEvent; // Event counter
+    TH1D *fEvent;  // Event counter
+    TH1D *fCC;     // CC histogram
+    TH1D *fRFPMTPC; // Multiplicity RFPTPC
+    TH1D *fRFPPhiTPC; // Phi RFPTPC
 
     TObjArray *fCandidates; // Array of selected candidates
 
-  ClassDef(AliAnalysisTaskFlowD2H, 2);
+  ClassDef(AliAnalysisTaskFlowD2H, 3);
 };
 
 #endif