[u/mrichter/AliRoot.git] / PWGHF / vertexingHF / charmFlow / AddTaskFlowD2HconfigurableTPC.C

class AliAnalysisDataContainer;
class AliFlowEventCuts;
class AliFlowEventTrackCuts;
class AliFlowEventTrackSimpleCuts;
class AliRDHFCutsD0toKpi;
class AliRDHFCutsDStartoKpipi; 

void AddTaskFlowD2HconfigurableTPC(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 etaTPC1, Double_t etaTPC2, Double_t etaTPC3, Double_t etaTPC4,
		     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.");
  }

  TString fileName = AliAnalysisManager::GetCommonFileName();
  fileName.ReplaceAll(".root","");

  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();

  TString thecuts = folderName;
  TString sgn = DMesonName( nDmeson ) + Form("w%d",ptBinWidth);

  //**********************************************************************
  // FLOW TRACK CUTS
  AliFlowTrackCuts* cutsRFPTPC = new AliFlowTrackCuts( "GlobalRFPTPC" );
  cutsRFPTPC->SetParamType(AliFlowTrackCuts::kGlobal);
  cutsRFPTPC->SetPtRange(0.2,5.);
  cutsRFPTPC->SetEtaRange(etaTPC1,etaTPC4);
  cutsRFPTPC->SetMinNClustersTPC(70);
  cutsRFPTPC->SetMinChi2PerClusterTPC(0.2);
  cutsRFPTPC->SetMaxChi2PerClusterTPC(4.0);
  cutsRFPTPC->SetAcceptKinkDaughters(kFALSE);
  cutsRFPTPC->SetMinimalTPCdedx(10.);
  cutsRFPTPC->SetAODfilterBit(1);
  //  cutsRFPTPC->SetQA(kTRUE);
  AliFlowTrackCuts* cutsRFPVZE = new AliFlowTrackCuts( "GlobalRFPVZE" );
  cutsRFPVZE->SetParamType(AliFlowTrackCuts::kVZERO);
  cutsRFPVZE->SetEtaRange(etaVZERO1,etaVZERO4);
  cutsRFPVZE->SetPhiMin(0);
  cutsRFPVZE->SetPhiMax(TMath::TwoPi());
  //  cutsRFPVZE->SetQA(kTRUE);
  AliFlowTrackCuts* cutsPOI = new AliFlowTrackCuts( "GlobalPOI" );
  cutsPOI->SetParamType(AliFlowTrackCuts::kGlobal);
  cutsPOI->SetPtRange(0.2,-5.);
  cutsPOI->SetEtaRange(0.8,-0.8);

  //**********************************************************************
  // POI FILTER CUTS
  AliFlowTrackSimpleCuts *filterPOIQC[50]; // MASS BANDS
  AliFlowTrackSimpleCuts *filterPOISP[50][2]; // MASS BANDS || ETA || SUBEVENT GAP
  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( etaTPC1 );
    filterPOISP[mb][0]->SetEtaMax( etaTPC2 );
    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( etaTPC3 );
    filterPOISP[mb][1]->SetEtaMax( etaTPC4 );
    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( etaTPC1 );
    filterPOIQC[mb]->SetEtaMax( etaTPC4 );
    filterPOIQC[mb]->SetMassMin( MassBandLowEdge(nDmeson,mb,bOldApproach) );
    filterPOIQC[mb]->SetMassMax( MassBandLowEdge(nDmeson,mb+1,bOldApproach) );
  }

  // * DMESON SELECTOR *************************************************
  AliAnalysisTaskFlowD2H *taskSel;
  switch (nDmeson) {
  case ( AliRDHFCuts::kD0toKpiCuts ):
    AliRDHFCutsD0toKpi *myCutsD0 = (AliRDHFCutsD0toKpi*)filecuts->Get("D0toKpiCuts");
    if(!myCutsD0) {
      AliFatal("Problems reaching D0toKpiCuts");
    }
    taskSel = new AliAnalysisTaskFlowD2H( Form("TaskD0Selector_%s",thecuts.Data()), 
					  cutsRFPTPC, cutsRFPVZE, myCutsD0, nDmeson );
    break;
  case ( AliRDHFCuts::kDstarCuts ):
    AliRDHFCutsDStartoKpipi *myCutsDStar = (AliRDHFCutsDStartoKpipi*)filecuts->Get("DStartoKpipiCuts");
    if(!myCutsDStar) {
      AliFatal("Problems reaching DStarToKpipiCuts");
    }
    taskSel = new AliAnalysisTaskFlowD2H( Form("TaskDStarSelector_%s",thecuts.Data()),
					  cutsRFPTPC, cutsRFPVZE, myCutsDStar, nDmeson);
    break;
  case (AliRDHFCuts::kDplusCuts):
    AliRDHFCutsDplustoKpipi *myCutsDplus = (AliRDHFCutsDplustoKpipi*)filecuts->Get("AnalysisCuts");
    if(!myCutsDplus) {
      AliFatal("Problems reaching AnalysisCuts");
    }
    taskSel = new AliAnalysisTaskFlowD2H( Form("TaskDplusSelector_%s",thecuts.Data()), 
					  cutsRFPTPC, cutsRFPVZE, myCutsDplus, nDmeson );
    break;
  }
  taskSel->SetCommonConstants( MassBins(nDmeson), MinMass(nDmeson), MaxMass(nDmeson), ptBinWidth );

  //taskSel->SelectCollisionCandidates(trigger);
  //taskSel->SetDebug();
  AliAnalysisDataContainer *coutHist = mgr->CreateContainer( Form("%sSelector_%s",sgn.Data(),thecuts.Data()),
							     TList::Class(),AliAnalysisManager::kOutputContainer,
							     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,exc_TPC);
  mgr->ConnectOutput(taskSel,3,exc_VZE);
  mgr->ConnectInput (taskSel,0,cinput1);

  // * HANGING ANALYSIS TASKS ********************************************
  int harm = myHarmonic;
  for(int mb=0; mb!=myMassBands; ++mb) {
    if(bDoQC) {
      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), 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) {
      AddSPmethod( 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), fileName.Data(), thecuts.Data(), etaTPC1, etaTPC2-gapTPC*eg, etaTPC3+gapTPC*eg, etaTPC4,
		     "Qa", harm, exc_TPC, eg, filterPOISP[mb][1], NULL, false, shrinkSP );
	AddSPmethod( Form("%sSPTPCMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), etaTPC1, etaTPC2-gapTPC*eg, etaTPC3+gapTPC*eg, etaTPC4,
		     "Qb", harm, exc_TPC, eg, filterPOISP[mb][0], NULL, false, shrinkSP );
      }
    }
    if(bDoEPTPC) {
      AddSPmethod( Form("%sEPTPCMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), etaTPC1, etaTPC2, etaTPC3, etaTPC4,
		   "QaQb", harm, exc_TPC, 0, filterPOIQC[mb], NULL, true, shrinkSP );
    }
  }
}

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, 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(),
							       AliAnalysisManager::kExchangeContainer );
  AliAnalysisTaskFilterFE *tskFilter = new AliAnalysisTaskFilterFE( Form("TaskFilter_%s",myNameSP.Data()),
								    cutsRFP, cutsPOI);
  tskFilter->SetSubeventEtaRange( minEtaA, maxEtaA, minEtaB, maxEtaB );
  mgr->AddTask(tskFilter);
  mgr->ConnectInput( tskFilter,0,flowEvent);
  mgr->ConnectOutput(tskFilter,1,flowEvent2);
  AliAnalysisDataContainer *outSP = mgr->CreateContainer( myNameSP.Data(),
							  TList::Class(),AliAnalysisManager::kOutputContainer,
							  Form("%s.root:FlowD2H_SP_%s",fileName,myFolder.Data()) );
  AliAnalysisTaskScalarProduct *tskSP = new AliAnalysisTaskScalarProduct( Form("TaskScalarProduct_%s",
									       myNameSP.Data()),kFALSE);
  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);
}

void AddQCmethod(char *name, char *fileName, char *thecuts,
		 int harmonic, AliAnalysisDataContainer *flowEvent,
		 AliFlowTrackSimpleCuts *cutsPOI=NULL, AliFlowTrackSimpleCuts *cutsRFP=NULL) {
  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(),
							       AliAnalysisManager::kExchangeContainer );
  AliAnalysisTaskFilterFE *tskFilter = new AliAnalysisTaskFilterFE( Form("TaskFilter_%s",myName.Data()),
								    cutsRFP, cutsPOI);
  mgr->AddTask(tskFilter);
  mgr->ConnectInput( tskFilter,0,flowEvent);
  mgr->ConnectOutput(tskFilter,1,flowEvent2);
  AliAnalysisDataContainer *outQC = mgr->CreateContainer( myName.Data(),
							  TList::Class(),AliAnalysisManager::kOutputContainer,
							  Form("%s.root:FlowD2H_QC_%s",fileName,myFolder.Data()) );
  AliAnalysisTaskQCumulants *tskQC = new AliAnalysisTaskQCumulants( Form("TaskQCumulants_%s",
									 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);
}

int MassBands( int nDmeson, bool bOldApproach=false ) {
  switch (nDmeson) {
  case ( AliRDHFCuts::kDplusCuts ):
  case ( AliRDHFCuts::kD0toKpiCuts ):
    if(bOldApproach) return 5;
    else return 26;
  case ( AliRDHFCuts::kDstarCuts ):
    return 20;
  }
}

double MassBandLowEdge( int nDmeson, int mb, bool bOldApproach=false ) {
  switch (nDmeson) {
  case ( AliRDHFCuts::kDplusCuts ):
  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 ): // 2 + 10 + 3
    double lowEdge[20+1] = {0.1380, 0.1396, 0.1412, 0.1420, 0.1428, 0.1436, 0.1444, 0.1452, 0.1460, 0.1468, 0.1476, 0.1484, 0.1492, 0.1500,
			    0.1508, 0.1516, 0.1524, 0.1532, 0.1548, 0.1564, 0.1580};
    return lowEdge[mb];
  }
}

double MinMass( int nDmeson ) {
  switch (nDmeson) {
  case ( AliRDHFCuts::kDplusCuts ):
  case ( AliRDHFCuts::kD0toKpiCuts ):
    return 1.66;
  case ( AliRDHFCuts::kDstarCuts ):
    return 0.138;
  }
}

double MaxMass( int nDmeson ) {
  switch (nDmeson) {
  case ( AliRDHFCuts::kDplusCuts ):
  case ( AliRDHFCuts::kD0toKpiCuts ):
    return 2.16;
  case ( AliRDHFCuts::kDstarCuts ):
    return 0.158;
  }
}

int MassBins( int nDmeson ) {
  switch (nDmeson) {
  case ( AliRDHFCuts::kDplusCuts ):
  case ( AliRDHFCuts::kD0toKpiCuts ):
    return 50;
  case ( AliRDHFCuts::kDstarCuts ):
    return 25;
  }
}

TString DMesonName( int nDmeson ) {
  TString toReturn;
  switch (nDmeson) {
  case ( AliRDHFCuts::kDplusCuts ):
    toReturn = "DPlus"; break;
  case ( AliRDHFCuts::kD0toKpiCuts ):
    toReturn = "D0"; break;
  case ( AliRDHFCuts::kDstarCuts ):
    toReturn = "DStar"; break;
  }
  return toReturn;
}
Commit	Line	Data
b5855a40	1	class AliAnalysisDataContainer;
	2	class AliFlowEventCuts;
	3	class AliFlowEventTrackCuts;
	4	class AliFlowEventTrackSimpleCuts;
	5	class AliRDHFCutsD0toKpi;
	6	class AliRDHFCutsDStartoKpipi;
	7
	8	void AddTaskFlowD2HconfigurableTPC(TString fileNameCuts, TString folderName, Int_t nDmeson, Int_t myHarmonic,
	9	Bool_t bDoQC, Bool_t bDoSPTPC, Bool_t bDoSPVZERO, Bool_t bDoEPTPC, Bool_t bDoEPVZERO,
	10	Int_t ptBinWidth, Double_t gapTPC,
	11	Double_t etaTPC1, Double_t etaTPC2, Double_t etaTPC3, Double_t etaTPC4,
	12	Double_t etaVZERO1, Double_t etaVZERO2, Double_t etaVZERO3, Double_t etaVZERO4,
	13	Bool_t bOldApproach=kFALSE, Bool_t shrinkSP=kFALSE ) {
	14	TFile *filecuts = TFile::Open( fileNameCuts.Data() );
	15	if( (!filecuts) \|\| ( filecuts && !filecuts->IsOpen()) ){
	16	AliFatal("Could not open cuts file.");
	17	}
	18
	19	TString fileName = AliAnalysisManager::GetCommonFileName();
	20	fileName.ReplaceAll(".root","");
	21
	22	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	23	AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
	24
	25	TString thecuts = folderName;
	26	TString sgn = DMesonName( nDmeson ) + Form("w%d",ptBinWidth);
	27
	28	//**********************************************************************
	29	// FLOW TRACK CUTS
	30	AliFlowTrackCuts* cutsRFPTPC = new AliFlowTrackCuts( "GlobalRFPTPC" );
	31	cutsRFPTPC->SetParamType(AliFlowTrackCuts::kGlobal);
	32	cutsRFPTPC->SetPtRange(0.2,5.);
	33	cutsRFPTPC->SetEtaRange(etaTPC1,etaTPC4);
	34	cutsRFPTPC->SetMinNClustersTPC(70);
	35	cutsRFPTPC->SetMinChi2PerClusterTPC(0.2);
	36	cutsRFPTPC->SetMaxChi2PerClusterTPC(4.0);
	37	cutsRFPTPC->SetAcceptKinkDaughters(kFALSE);
	38	cutsRFPTPC->SetMinimalTPCdedx(10.);
	39	cutsRFPTPC->SetAODfilterBit(1);
	40	// cutsRFPTPC->SetQA(kTRUE);
	41	AliFlowTrackCuts* cutsRFPVZE = new AliFlowTrackCuts( "GlobalRFPVZE" );
9579a93f	42	cutsRFPVZE->SetParamType(AliFlowTrackCuts::kVZERO);
b5855a40	43	cutsRFPVZE->SetEtaRange(etaVZERO1,etaVZERO4);
	44	cutsRFPVZE->SetPhiMin(0);
	45	cutsRFPVZE->SetPhiMax(TMath::TwoPi());
	46	// cutsRFPVZE->SetQA(kTRUE);
	47	AliFlowTrackCuts* cutsPOI = new AliFlowTrackCuts( "GlobalPOI" );
	48	cutsPOI->SetParamType(AliFlowTrackCuts::kGlobal);
	49	cutsPOI->SetPtRange(0.2,-5.);
	50	cutsPOI->SetEtaRange(0.8,-0.8);
	51
	52	//**********************************************************************
	53	// POI FILTER CUTS
	54	AliFlowTrackSimpleCuts *filterPOIQC[50]; // MASS BANDS
	55	AliFlowTrackSimpleCuts *filterPOISP[50][2]; // MASS BANDS \|\| ETA \|\| SUBEVENT GAP
	56	int myMassBands = MassBands( nDmeson, bOldApproach );
	57	for(int mb=0; mb!=myMassBands; ++mb) {
	58	filterPOISP[mb][0] = new AliFlowTrackSimpleCuts( Form("FilterPOISP_MB%d_ETANEG",mb) );
	59	filterPOISP[mb][0]->SetEtaMin( etaTPC1 );
	60	filterPOISP[mb][0]->SetEtaMax( etaTPC2 );
	61	filterPOISP[mb][0]->SetMassMin( MassBandLowEdge(nDmeson,mb,bOldApproach) );
	62	filterPOISP[mb][0]->SetMassMax( MassBandLowEdge(nDmeson,mb+1,bOldApproach) );
	63	filterPOISP[mb][1] = new AliFlowTrackSimpleCuts( Form("FilterPOISP_MB%d_ETAPOS",mb) );
	64	filterPOISP[mb][1]->SetEtaMin( etaTPC3 );
	65	filterPOISP[mb][1]->SetEtaMax( etaTPC4 );
	66	filterPOISP[mb][1]->SetMassMin( MassBandLowEdge(nDmeson,mb,bOldApproach) );
	67	filterPOISP[mb][1]->SetMassMax( MassBandLowEdge(nDmeson,mb+1,bOldApproach) );
	68	filterPOIQC[mb] = new AliFlowTrackSimpleCuts( Form("FilterPOIQC_MB%d",mb) );
	69	filterPOIQC[mb]->SetEtaMin( etaTPC1 );
	70	filterPOIQC[mb]->SetEtaMax( etaTPC4 );
	71	filterPOIQC[mb]->SetMassMin( MassBandLowEdge(nDmeson,mb,bOldApproach) );
	72	filterPOIQC[mb]->SetMassMax( MassBandLowEdge(nDmeson,mb+1,bOldApproach) );
	73	}
	74
	75	// * DMESON SELECTOR *************************************************
	76	AliAnalysisTaskFlowD2H *taskSel;
	77	switch (nDmeson) {
	78	case ( AliRDHFCuts::kD0toKpiCuts ):
	79	AliRDHFCutsD0toKpi myCutsD0 = (AliRDHFCutsD0toKpi)filecuts->Get("D0toKpiCuts");
	80	if(!myCutsD0) {
	81	AliFatal("Problems reaching D0toKpiCuts");
	82	}
	83	taskSel = new AliAnalysisTaskFlowD2H( Form("TaskD0Selector_%s",thecuts.Data()),
	84	cutsRFPTPC, cutsRFPVZE, myCutsD0, nDmeson );
	85	break;
	86	case ( AliRDHFCuts::kDstarCuts ):
	87	AliRDHFCutsDStartoKpipi myCutsDStar = (AliRDHFCutsDStartoKpipi)filecuts->Get("DStartoKpipiCuts");
	88	if(!myCutsDStar) {
	89	AliFatal("Problems reaching DStarToKpipiCuts");
	90	}
	91	taskSel = new AliAnalysisTaskFlowD2H( Form("TaskDStarSelector_%s",thecuts.Data()),
	92	cutsRFPTPC, cutsRFPVZE, myCutsDStar, nDmeson);
	93	break;
	94	case (AliRDHFCuts::kDplusCuts):
	95	AliRDHFCutsDplustoKpipi myCutsDplus = (AliRDHFCutsDplustoKpipi)filecuts->Get("AnalysisCuts");
	96	if(!myCutsDplus) {
	97	AliFatal("Problems reaching AnalysisCuts");
	98	}
	99	taskSel = new AliAnalysisTaskFlowD2H( Form("TaskDplusSelector_%s",thecuts.Data()),
	100	cutsRFPTPC, cutsRFPVZE, myCutsDplus, nDmeson );
	101	break;
	102	}
	103	taskSel->SetCommonConstants( MassBins(nDmeson), MinMass(nDmeson), MaxMass(nDmeson), ptBinWidth );
	104
	105	//taskSel->SelectCollisionCandidates(trigger);
	106	//taskSel->SetDebug();
107	AliAnalysisDataContainer *coutHist = mgr->CreateContainer( Form("%sSelector_%s",sgn.Data(),thecuts.Data()),
108	TList::Class(),AliAnalysisManager::kOutputContainer,
109	Form("%s.root:FlowD2H_%s",fileName.Data(),thecuts.Data()) );
110	AliAnalysisDataContainer *exc_TPC = mgr->CreateContainer( Form("TPCEventWithCandidates_%s_%s",sgn.Data(),thecuts.Data()),
111	AliFlowEventSimple::Class(),
112	AliAnalysisManager::kExchangeContainer );
113	AliAnalysisDataContainer *exc_VZE = mgr->CreateContainer( Form("VZEEventWithCandidates_%s_%s",sgn.Data(),thecuts.Data()),
114	AliFlowEventSimple::Class(),
115	AliAnalysisManager::kExchangeContainer );
116	mgr->AddTask(taskSel);
117	mgr->ConnectOutput(taskSel,1,coutHist);
118	mgr->ConnectOutput(taskSel,2,exc_TPC);
119	mgr->ConnectOutput(taskSel,3,exc_VZE);
120	mgr->ConnectInput (taskSel,0,cinput1);
121
122	// * HANGING ANALYSIS TASKS ********************************************
123	int harm = myHarmonic;
124	for(int mb=0; mb!=myMassBands; ++mb) {
125	if(bDoQC) {
126	AddQCmethod( Form("%sQCTPCMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), harm, exc_TPC, filterPOIQC[mb]);
127	}
128	if(bDoSPVZERO) {
129	AddSPmethod( Form("%sSPVZEMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), etaVZERO1, etaVZERO2, etaVZERO3, etaVZERO4,
130	"Qa", harm, exc_VZE, 0, filterPOIQC[mb], NULL, false, shrinkSP );
131	AddSPmethod( Form("%sSPVZEMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), etaVZERO1, etaVZERO2, etaVZERO3, etaVZERO4,
132	"Qb", harm, exc_VZE, 0, filterPOIQC[mb], NULL, false, shrinkSP );
133	}
134	if(bDoEPVZERO) {
135	AddSPmethod( Form("%sEPVZEMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), etaVZERO1, etaVZERO2, etaVZERO3, etaVZERO4,
136	"QaQb", harm, exc_VZE, 0, filterPOIQC[mb], NULL, true, shrinkSP );
137	}
138	if(bDoSPTPC) {
139	for(int eg=0; eg!=2; ++eg) {
140	AddSPmethod( Form("%sSPTPCMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), etaTPC1, etaTPC2-gapTPCeg, etaTPC3+gapTPCeg, etaTPC4,
141	"Qa", harm, exc_TPC, eg, filterPOISP[mb][1], NULL, false, shrinkSP );
142	AddSPmethod( Form("%sSPTPCMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), etaTPC1, etaTPC2-gapTPCeg, etaTPC3+gapTPCeg, etaTPC4,
143	"Qb", harm, exc_TPC, eg, filterPOISP[mb][0], NULL, false, shrinkSP );
144	}
145	}
146	if(bDoEPTPC) {
147	AddSPmethod( Form("%sEPTPCMB%d",sgn.Data(),mb), fileName.Data(), thecuts.Data(), etaTPC1, etaTPC2, etaTPC3, etaTPC4,
148	"QaQb", harm, exc_TPC, 0, filterPOIQC[mb], NULL, true, shrinkSP );
149	}
150	}
151	}
152
153	void AddSPmethod(char name, char fileName, char *thecuts,
154	double minEtaA, double maxEtaA, double minEtaB, double maxEtaB,
155	char Qvector, int harmonic, AliAnalysisDataContainer flowEvent, int eg,
156	AliFlowTrackSimpleCuts cutsPOI=NULL, AliFlowTrackSimpleCuts cutsRFP=NULL,
157	bool bEP, bool shrink=false ) {
158	TString myFolder = Form("v%d_%s",harmonic,thecuts);
159	TString myNameSP = Form("%sSPv%d%sGAP%d_%s",name,harmonic,Qvector,eg,thecuts);
160	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
161	AliAnalysisDataContainer *flowEvent2 = mgr->CreateContainer( Form("Filter_%s", myNameSP.Data()),
162	AliFlowEventSimple::Class(),
163	AliAnalysisManager::kExchangeContainer );
164	AliAnalysisTaskFilterFE *tskFilter = new AliAnalysisTaskFilterFE( Form("TaskFilter_%s",myNameSP.Data()),
165	cutsRFP, cutsPOI);
166	tskFilter->SetSubeventEtaRange( minEtaA, maxEtaA, minEtaB, maxEtaB );
167	mgr->AddTask(tskFilter);
168	mgr->ConnectInput( tskFilter,0,flowEvent);
169	mgr->ConnectOutput(tskFilter,1,flowEvent2);
170	AliAnalysisDataContainer *outSP = mgr->CreateContainer( myNameSP.Data(),
171	TList::Class(),AliAnalysisManager::kOutputContainer,
172	Form("%s.root:FlowD2H_SP_%s",fileName,myFolder.Data()) );
173	AliAnalysisTaskScalarProduct *tskSP = new AliAnalysisTaskScalarProduct( Form("TaskScalarProduct_%s",
174	myNameSP.Data()),kFALSE);
175	tskSP->SetApplyCorrectionForNUA(kTRUE);
176	tskSP->SetHarmonic(harmonic);
177	tskSP->SetTotalQvector(Qvector);
178	if(bEP) tskSP->SetBehaveAsEP();
179	if(shrink) tskSP->SetBookOnlyBasicCCH(kTRUE);
180	mgr->AddTask(tskSP);
181	mgr->ConnectInput( tskSP,0,flowEvent2);
182	mgr->ConnectOutput(tskSP,1,outSP);
183	}
184
185	void AddQCmethod(char name, char fileName, char *thecuts,
186	int harmonic, AliAnalysisDataContainer *flowEvent,
187	AliFlowTrackSimpleCuts cutsPOI=NULL, AliFlowTrackSimpleCuts cutsRFP=NULL) {
188	TString myFolder = Form("v%d_%s",harmonic,thecuts);
189	TString myName = Form("%sv%d_%s",name,harmonic,thecuts);
190	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
191	AliAnalysisDataContainer *flowEvent2 = mgr->CreateContainer( Form("Filter_%s", myName.Data()),
192	AliFlowEventSimple::Class(),
193	AliAnalysisManager::kExchangeContainer );
194	AliAnalysisTaskFilterFE *tskFilter = new AliAnalysisTaskFilterFE( Form("TaskFilter_%s",myName.Data()),
195	cutsRFP, cutsPOI);
196	mgr->AddTask(tskFilter);
197	mgr->ConnectInput( tskFilter,0,flowEvent);
198	mgr->ConnectOutput(tskFilter,1,flowEvent2);
199	AliAnalysisDataContainer *outQC = mgr->CreateContainer( myName.Data(),
200	TList::Class(),AliAnalysisManager::kOutputContainer,
201	Form("%s.root:FlowD2H_QC_%s",fileName,myFolder.Data()) );
202	AliAnalysisTaskQCumulants *tskQC = new AliAnalysisTaskQCumulants( Form("TaskQCumulants_%s",
203	myName.Data()),kFALSE);
204	tskQC->SetApplyCorrectionForNUA(kTRUE);
205	tskQC->SetHarmonic(harmonic);
206	tskQC->SetBookOnlyBasicCCH(kTRUE);
207	mgr->AddTask(tskQC);
208	mgr->ConnectInput( tskQC,0,flowEvent2);
209	mgr->ConnectOutput(tskQC,1,outQC);
210	}
211
212	int MassBands( int nDmeson, bool bOldApproach=false ) {
213	switch (nDmeson) {
214	case ( AliRDHFCuts::kDplusCuts ):
215	case ( AliRDHFCuts::kD0toKpiCuts ):
216	if(bOldApproach) return 5;
217	else return 26;
218	case ( AliRDHFCuts::kDstarCuts ):
219	return 20;
220	}
221	}
222
223	double MassBandLowEdge( int nDmeson, int mb, bool bOldApproach=false ) {
224	switch (nDmeson) {
225	case ( AliRDHFCuts::kDplusCuts ):
226	case ( AliRDHFCuts::kD0toKpiCuts ): // 2 + 20 + 4
227	double lowEdgeMinimal[5+1] = {1.75,1.80,1.83,1.90,1.93,2.03};
228	double lowEdge[26+1] = { 1.66, 1.71, 1.76, 1.77, 1.78, 1.79, 1.80, 1.81, 1.82, 1.83,
229	1.84, 1.85, 1.86, 1.87, 1.88, 1.89, 1.90, 1.91, 1.92, 1.93,
230	1.94, 1.95, 1.96, 2.01, 2.06, 2.11, 2.16 };
231	if(bOldApproach) return lowEdgeMinimal[mb];
232	else return lowEdge[mb];
233	case ( AliRDHFCuts::kDstarCuts ): // 2 + 10 + 3
234	double lowEdge[20+1] = {0.1380, 0.1396, 0.1412, 0.1420, 0.1428, 0.1436, 0.1444, 0.1452, 0.1460, 0.1468, 0.1476, 0.1484, 0.1492, 0.1500,
235	0.1508, 0.1516, 0.1524, 0.1532, 0.1548, 0.1564, 0.1580};
236	return lowEdge[mb];
237	}
238	}
239
240	double MinMass( int nDmeson ) {
241	switch (nDmeson) {
242	case ( AliRDHFCuts::kDplusCuts ):
243	case ( AliRDHFCuts::kD0toKpiCuts ):
244	return 1.66;
245	case ( AliRDHFCuts::kDstarCuts ):
246	return 0.138;
247	}
248	}
249
250	double MaxMass( int nDmeson ) {
251	switch (nDmeson) {
252	case ( AliRDHFCuts::kDplusCuts ):
253	case ( AliRDHFCuts::kD0toKpiCuts ):
254	return 2.16;
255	case ( AliRDHFCuts::kDstarCuts ):
256	return 0.158;
257	}
258	}
259
260	int MassBins( int nDmeson ) {
261	switch (nDmeson) {
262	case ( AliRDHFCuts::kDplusCuts ):
263	case ( AliRDHFCuts::kD0toKpiCuts ):
264	return 50;
265	case ( AliRDHFCuts::kDstarCuts ):
266	return 25;
267	}
268	}
269
270	TString DMesonName( int nDmeson ) {
271	TString toReturn;
272	switch (nDmeson) {
273	case ( AliRDHFCuts::kDplusCuts ):
274	toReturn = "DPlus"; break;
275	case ( AliRDHFCuts::kD0toKpiCuts ):
276	toReturn = "D0"; break;
277	case ( AliRDHFCuts::kDstarCuts ):
278	toReturn = "DStar"; break;
279	}
280	return toReturn;
281	}