[u/mrichter/AliRoot.git] / PWGCF / Correlations / macros / dptdptcorrelations / AddTaskDptQA.C

//           system:  0: PbPb                 1: pp
//      singlesOnly:  0: full correlations    1: singles only
//       useWeights:  0: no                   1: yes
// centralityMethod:  3: track count  4: V0 centrality
/////////////////////////////////////////////////////////////////////////////////
AliAnalysisTaskDptDptQA *AddTaskDptQA
(int    system                 = 0,
 int    singlesOnly            = 0,
 int    useWeights             = 0,
 int    centralityMethod       = 4,
 int    centralitySelected     = 4,
 double etaMin                 = -0.8,
 double etaMax                 =  0.8,
 int    trackFilterBit         =  128,
 char *inputHistogramFileName  = "alien:///alice/cern.ch/user/p/prabhat/CalibFiles/PbPbCalib_dca1.root"
 )
  
{
  // Set Default Configuration of this analysis
  // ==========================================
  int    debugLevel             = 0;
  int    rejectPileup           = 1;
  int    rejectPairConversion   = 1;
  int    sameFilter             = 1;
  
  int    nCentrality;
  double minCentrality[10];
  double maxCentrality[10];

  if (system==0) // PbPb
    {
      if (centralityMethod == 4)
	{
	  nCentrality = 10;
	  minCentrality[0] = 0.0; maxCentrality[0] = 5.0;
	  minCentrality[1] = 5.0; maxCentrality[1] = 10.;
	  minCentrality[2] = 10.; maxCentrality[2] = 20.;
	  minCentrality[3] = 20.; maxCentrality[3] = 30.;
	  minCentrality[4] = 30.; maxCentrality[4] = 40.;
	  minCentrality[5] = 40.; maxCentrality[5] = 50.;
	  minCentrality[6] = 50.; maxCentrality[6] = 60.;
	  minCentrality[7] = 60.; maxCentrality[7] = 70.;
	  minCentrality[8] = 70.; maxCentrality[8] = 80.;
	  minCentrality[9] = 80.; maxCentrality[9] = 90.;
	  
	}
      else
	{
	  
	  return 0;
	}
    }
  
  double zMin                   = -10.;
  double zMax                   =  10.;
  double ptMin                  =  0.2;
  double ptMax                  =  2.0;
  
  double dcaZMin                = -3.0;
  double dcaZMax                =  3.0;
  double dcaXYMin               = -3.0;
  double dcaXYMax               =  3.0;
  double dedxMin                =  0.0;
  double dedxMax                =  20000.0;
  int    nClusterMin            =   70;
  int    requestedCharge1       =  1; //default
  int    requestedCharge2       = -1; //default
  
  
  // Get the pointer to the existing analysis manager via the static access method.
  // ==============================================================================
  AliAnalysisManager *analysisManager = AliAnalysisManager::GetAnalysisManager();
  
  if (!analysisManager) 
    {
    ::Error("AddTaskDptDptCorrelations", "No analysis manager to connect to.");
    return NULL;
    }  
  
  TString part1Name;
  TString part2Name;
  TString eventName;
  TString prefixName        = "Corr_";
  TString pileupRejecSuffix = "_PileupRejec";
  TString pairRejecSuffix   = "_PairRejec";
  TString calibSuffix       = "_calib";
  TString singlesOnlySuffix = "_SO";
  TString suffix;
  
  TString inputPath         = ".";
  TString outputPath        = ".";
  TString baseName;
  TString listName;
  TString taskName;
  TString outputHistogramFileName;
  
  // Create the task and add subtask.
  // ===========================================================================
  int iTask = 0; // task counter
  AliAnalysisDataContainer *taskInputContainer;
  AliAnalysisDataContainer *taskOutputContainer;
  AliAnalysisTaskDptDptQA* task;

  TFile  * inputFile  = 0;
  TList  * histoList  = 0;
  TH3F   * weight_1   = 0;
  TH3F   * weight_2   = 0;
  
  int iCentrality = centralitySelected;
  outputHistogramFileName = baseName;
  if (singlesOnly) outputHistogramFileName += singlesOnlySuffix;
  outputHistogramFileName += ".root";

  if (useWeights)
  {
    TGrid::Connect("alien:");
    inputFile = TFile::Open(inputHistogramFileName,"OLD");
    if (!inputFile)
      {
      cout << "Requested file:" << inputHistogramFileName << " was not opened. ABORT." << endl;
      return;
      }
    }
  
  //============================
  // (+,+)
  //============================
  requestedCharge1 = 1;
  requestedCharge2 = 1;
  sameFilter = 1;
  part1Name = "P_";
  part1Name += trackFilterBit;
  part1Name += "_";
  part1Name += int(1000*etaMax);
  part1Name += "_";
  part1Name += int(1000*ptMin);
  part1Name += "pt";
  part1Name += int(1000*ptMax);
  part1Name += "_";
  part2Name = "P_"; 
  part2Name += int(1000*etaMax);
  part2Name += "_";
  part2Name += int(1000*ptMin);
  part2Name += "pt";
  part2Name += int(1000*ptMax);
  part2Name += "_";
  eventName =  "";
  eventName += int(10.*minCentrality[iCentrality] );
  eventName += "Vo";
  eventName += int(10.*maxCentrality[iCentrality] );
  baseName  =   prefixName;
  baseName  +=  part1Name;
  baseName  +=  part2Name;
  baseName  +=  eventName;
  listName  =   baseName;
  taskName  =   baseName;
  if (useWeights)
    {
    TString nameHistoBase = "correction_";
    TString nameHisto;
    nameHistoBase += eventName;
    nameHisto = nameHistoBase + "_p";
    cout << "Input Histogram named: " << nameHisto << endl;
    weight_1 = (TH3F *) inputFile->Get(nameHisto);
    weight_2 = weight_1;
    }
  else
    {
    weight_1 = 0;
    weight_2 = 0;
    }
  task = new  AliAnalysisTaskDptDptQA(taskName);
  //configure my task
  task->SetDebugLevel(          debugLevel      ); 
  task->SetSameFilter(          sameFilter      );
  task->SetSinglesOnly(         singlesOnly     ); 
  task->SetUseWeights(          useWeights      ); 
  task->SetRejectPileup(        rejectPileup    ); 
  task->SetRejectPairConversion(rejectPairConversion); 
  task->SetVertexZMin(          zMin            ); 
  task->SetVertexZMax(          zMax            ); 
  task->SetVertexXYMin(         -1.            ); 
  task->SetVertexXYMax(          1.            ); 
  task->SetCentralityMethod(    centralityMethod);
  task->SetCentrality(          minCentrality[iCentrality], maxCentrality[iCentrality]);
  task->SetPtMin1(              ptMin           ); 
  task->SetPtMax1(              ptMax           ); 
  task->SetEtaMin1(             etaMin          ); 
  task->SetEtaMax1(             etaMax          ); 
  task->SetPtMin2(              ptMin           ); 
  task->SetPtMax2(              ptMax           ); 
  task->SetEtaMin2(             etaMin          ); 
  task->SetEtaMax2(             etaMax          ); 
  task->SetDcaZMin(             dcaZMin         ); 
  task->SetDcaZMax(             dcaZMax         ); 
  task->SetDcaXYMin(            dcaXYMin        ); 
  task->SetDcaXYMax(            dcaXYMax        ); 
  task->SetDedxMin(             dedxMin         ); 
  task->SetDedxMax(             dedxMax         ); 
  task->SetNClusterMin(         nClusterMin     ); 
  task->SetTrackFilterBit(      trackFilterBit  );
  task->SetRequestedCharge_1(   requestedCharge1); 
  task->SetRequestedCharge_2(   requestedCharge2); 
  task->SetWeigth_1(            weight_1        );
  task->SetWeigth_2(            weight_2        );
  
  
  cout << "Creating task output container" << endl;
  taskOutputContainer = analysisManager->CreateContainer(listName, 
                                                         TList::Class(),    
                                                         AliAnalysisManager::kOutputContainer, 
                                                         Form("%s:Histos", AliAnalysisManager::GetCommonFileName()));
  cout << "Add task to analysis manager and connect it to input and output containers" << endl;
  analysisManager->AddTask(task);
  analysisManager->ConnectInput( task,  0, analysisManager->GetCommonInputContainer());
  analysisManager->ConnectOutput(task,  0, taskOutputContainer );
  cout << "(+,+) Task added ...." << endl;
  
  //============================
  // (+,-)
  //============================
  requestedCharge1 =  1;
  requestedCharge2 = -1;
  sameFilter = 0;
  part1Name = "P_"; 
  part1Name += trackFilterBit;
  part1Name += "_";    
  part1Name += int(1000*etaMax);
  part1Name += "_";
  part1Name += int(1000*ptMin);
  part1Name += "pt";
  part1Name += int(1000*ptMax);
  part1Name += "_";
  part2Name = "M_"; 
  part2Name += trackFilterBit;
  part2Name += int(1000*etaMax);
  part2Name += "_";
  part2Name += int(1000*ptMin);
  part2Name += "pt";
  part2Name += int(1000*ptMax);
  part2Name += "_";
  eventName =  "";
  eventName += int(10.*minCentrality[iCentrality] );
  eventName += "Vo";
  eventName += int(10.*maxCentrality[iCentrality] );
  baseName  =   prefixName;
  baseName  +=  part1Name;
  baseName  +=  part2Name;
  baseName  +=  eventName;
  listName  =   baseName;
  taskName  =   baseName;
  if (useWeights)
    {
    TString nameHistoBase = "correction_";
    TString nameHisto;
    nameHistoBase += eventName;
    nameHisto = nameHistoBase + "_p";
    cout << "Input Histogram named: " << nameHisto << endl;
    weight_1 = (TH3F *) inputFile->Get(nameHisto);
    nameHisto = nameHistoBase + "_m";
    cout << "Input Histogram named: " << nameHisto << endl;
    weight_2 = (TH3F *) inputFile->Get(nameHisto);
    }
  else
    {
    weight_1 = 0;
    weight_2 = 0;
    }
  task = new  AliAnalysisTaskDptDptQA(taskName);
  //configure my task
  task->SetDebugLevel(          debugLevel      ); 
  task->SetSameFilter(          sameFilter      );
  task->SetSinglesOnly(         singlesOnly     ); 
  task->SetUseWeights(          useWeights      ); 
  task->SetRejectPileup(        rejectPileup    ); 
  task->SetRejectPairConversion(rejectPairConversion); 
  task->SetVertexZMin(          zMin            ); 
  task->SetVertexZMax(          zMax            ); 
  task->SetVertexXYMin(         -1.            ); 
  task->SetVertexXYMax(          1.            ); 
  task->SetCentralityMethod(    centralityMethod);
  task->SetCentrality(          minCentrality[iCentrality], maxCentrality[iCentrality]);
  task->SetPtMin1(              ptMin           ); 
  task->SetPtMax1(              ptMax           ); 
  task->SetEtaMin1(             etaMin          ); 
  task->SetEtaMax1(             etaMax          ); 
  task->SetPtMin2(              ptMin           ); 
  task->SetPtMax2(              ptMax           ); 
  task->SetEtaMin2(             etaMin          ); 
  task->SetEtaMax2(             etaMax          ); 
  task->SetDcaZMin(             dcaZMin         ); 
  task->SetDcaZMax(             dcaZMax         ); 
  task->SetDcaXYMin(            dcaXYMin        ); 
  task->SetDcaXYMax(            dcaXYMax        ); 
  task->SetDedxMin(             dedxMin         ); 
  task->SetDedxMax(             dedxMax         ); 
  task->SetNClusterMin(         nClusterMin     ); 
  task->SetTrackFilterBit(      trackFilterBit  );
  task->SetRequestedCharge_1(   requestedCharge1); 
  task->SetRequestedCharge_2(   requestedCharge2); 
  task->SetWeigth_1(            weight_1        );
  task->SetWeigth_2(            weight_2        );
  
  
  cout << "Creating task output container" << endl;
  taskOutputContainer = analysisManager->CreateContainer(listName, 
                                                         TList::Class(),    
                                                         AliAnalysisManager::kOutputContainer, 
                                                         Form("%s:Histos", AliAnalysisManager::GetCommonFileName()));
  cout << "Add task to analysis manager and connect it to input and output containers" << endl;
  analysisManager->AddTask(task);
  analysisManager->ConnectInput( task,  0, analysisManager->GetCommonInputContainer());
  analysisManager->ConnectOutput(task,  0, taskOutputContainer );
  cout << "Task added ...." << endl;

  //============================
  // (-,-)
  //============================
  requestedCharge1 = -1;
  requestedCharge2 = -1;
  sameFilter = 1;
  part1Name = "M_"; 
  part1Name += trackFilterBit;
  part1Name += "_";
  part1Name += int(1000*etaMax);
  part1Name += "_";
  part1Name += int(1000*ptMin);
  part1Name += "pt";
  part1Name += int(1000*ptMax);
  part1Name += "_";
  part2Name = "M_"; 
  part2Name += trackFilterBit;
  part2Name += int(1000*etaMax);
  part2Name += "_";
  part2Name += int(1000*ptMin);
  part2Name += "pt";
  part2Name += int(1000*ptMax);
  part2Name += "_";
  eventName =  "";
  eventName += int(10.*minCentrality[iCentrality] );
  eventName += "Vo";
  eventName += int(10.*maxCentrality[iCentrality] );
  baseName  =   prefixName;
  baseName  +=  part1Name;
  baseName  +=  part2Name;
  baseName  +=  eventName;
  listName  =   baseName;
  taskName  =   baseName;
  if (useWeights)
    {
    TString nameHistoBase = "correction_";
    TString nameHisto;
    nameHistoBase += eventName;
    nameHisto = nameHistoBase + "_m";
    cout << "Input Histogram named: " << nameHisto << endl;
    weight_1 = (TH3F *) inputFile->Get(nameHisto);
    weight_2 = weight_1;
    }
  else
    {
    weight_1 = 0;
    weight_2 = 0;
    }
  task = new  AliAnalysisTaskDptDptQA(taskName);
  //configure my task
  task->SetDebugLevel(          debugLevel      ); 
  task->SetSameFilter(          sameFilter      );
  task->SetSinglesOnly(         singlesOnly     ); 
  task->SetUseWeights(          useWeights      ); 
  task->SetRejectPileup(        rejectPileup    ); 
  task->SetRejectPairConversion(rejectPairConversion); 
  task->SetVertexZMin(          zMin            ); 
  task->SetVertexZMax(          zMax            ); 
  task->SetVertexXYMin(         -1.            ); 
  task->SetVertexXYMax(          1.            ); 
  task->SetCentralityMethod(    centralityMethod);
  task->SetCentrality(          minCentrality[iCentrality], maxCentrality[iCentrality]);
  task->SetPtMin1(              ptMin           ); 
  task->SetPtMax1(              ptMax           ); 
  task->SetEtaMin1(             etaMin          ); 
  task->SetEtaMax1(             etaMax          ); 
  task->SetPtMin2(              ptMin           ); 
  task->SetPtMax2(              ptMax           ); 
  task->SetEtaMin2(             etaMin          ); 
  task->SetEtaMax2(             etaMax          ); 
  task->SetDcaZMin(             dcaZMin         ); 
  task->SetDcaZMax(             dcaZMax         ); 
  task->SetDcaXYMin(            dcaXYMin        ); 
  task->SetDcaXYMax(            dcaXYMax        ); 
  task->SetDedxMin(             dedxMin         ); 
  task->SetDedxMax(             dedxMax         ); 
  task->SetNClusterMin(         nClusterMin     ); 
  task->SetTrackFilterBit(      trackFilterBit  );
  task->SetRequestedCharge_1(   requestedCharge1); 
  task->SetRequestedCharge_2(   requestedCharge2); 
  task->SetWeigth_1(            weight_1        );
  task->SetWeigth_2(            weight_2        );
  
  
  cout << "Creating task output container" << endl;
  taskOutputContainer = analysisManager->CreateContainer(listName, 
                                                         TList::Class(),    
                                                         AliAnalysisManager::kOutputContainer, 
                                                         Form("%s:Histos", AliAnalysisManager::GetCommonFileName()));
  analysisManager->AddTask(task);
  analysisManager->ConnectInput( task,  0, analysisManager->GetCommonInputContainer());
  analysisManager->ConnectOutput(task,  0, taskOutputContainer );
  return task;
}
Commit	Line	Data
c5704d5c	1	// system: 0: PbPb 1: pp
143d78d1	2	// singlesOnly: 0: full correlations 1: singles only
143d78d1	3	// useWeights: 0: no 1: yes
c5704d5c	4	// centralityMethod: 3: track count 4: V0 centrality
143d78d1	5	/////////////////////////////////////////////////////////////////////////////////
2542e3ae	6	AliAnalysisTaskDptDptQA *AddTaskDptQA
	7	(int system = 0,
	8	int singlesOnly = 0,
	9	int useWeights = 0,
	10	int centralityMethod = 4,
c5704d5c	11	int centralitySelected = 4,
2542e3ae	12	double etaMin = -0.8,
c5704d5c	13	double etaMax = 0.8,
	14	int trackFilterBit = 128,
	15	char *inputHistogramFileName = "alien:///alice/cern.ch/user/p/prabhat/CalibFiles/PbPbCalib_dca1.root"
2542e3ae	16	)
	17
	18	{
	19	// Set Default Configuration of this analysis
	20	// ==========================================
	21	int debugLevel = 0;
	22	int rejectPileup = 1;
	23	int rejectPairConversion = 1;
	24	int sameFilter = 1;
2542e3ae	25
c5704d5c	26	int nCentrality;
2542e3ae	27	double minCentrality[10];
	28	double maxCentrality[10];
	29
	30	if (system==0) // PbPb
	31	{
c5704d5c	32	if (centralityMethod == 4)
	33	{
	34	nCentrality = 10;
	35	minCentrality[0] = 0.0; maxCentrality[0] = 5.0;
	36	minCentrality[1] = 5.0; maxCentrality[1] = 10.;
	37	minCentrality[2] = 10.; maxCentrality[2] = 20.;
	38	minCentrality[3] = 20.; maxCentrality[3] = 30.;
	39	minCentrality[4] = 30.; maxCentrality[4] = 40.;
	40	minCentrality[5] = 40.; maxCentrality[5] = 50.;
	41	minCentrality[6] = 50.; maxCentrality[6] = 60.;
	42	minCentrality[7] = 60.; maxCentrality[7] = 70.;
	43	minCentrality[8] = 70.; maxCentrality[8] = 80.;
	44	minCentrality[9] = 80.; maxCentrality[9] = 90.;
	45
	46	}
	47	else
	48	{
	49
	50	return 0;
	51	}
2542e3ae	52	}
c5704d5c	53
2542e3ae	54	double zMin = -10.;
	55	double zMax = 10.;
	56	double ptMin = 0.2;
	57	double ptMax = 2.0;
c5704d5c	58
	59	double dcaZMin = -3.0;
	60	double dcaZMax = 3.0;
	61	double dcaXYMin = -3.0;
	62	double dcaXYMax = 3.0;
2542e3ae	63	double dedxMin = 0.0;
2542e3ae	64	double dedxMax = 20000.0;
c5704d5c	65	int nClusterMin = 70;
2542e3ae	66	int requestedCharge1 = 1; //default
	67	int requestedCharge2 = -1; //default
	68
	69
	70	// Get the pointer to the existing analysis manager via the static access method.
	71	// ==============================================================================
	72	AliAnalysisManager *analysisManager = AliAnalysisManager::GetAnalysisManager();
	73
	74	if (!analysisManager)
	75	{
	76	::Error("AddTaskDptDptCorrelations", "No analysis manager to connect to.");
	77	return NULL;
	78	}
	79
	80	TString part1Name;
	81	TString part2Name;
	82	TString eventName;
	83	TString prefixName = "Corr_";
	84	TString pileupRejecSuffix = "_PileupRejec";
	85	TString pairRejecSuffix = "_PairRejec";
	86	TString calibSuffix = "_calib";
	87	TString singlesOnlySuffix = "_SO";
	88	TString suffix;
	89
	90	TString inputPath = ".";
	91	TString outputPath = ".";
	92	TString baseName;
	93	TString listName;
	94	TString taskName;
2542e3ae	95	TString outputHistogramFileName;
	96
	97	// Create the task and add subtask.
	98	// ===========================================================================
	99	int iTask = 0; // task counter
	100	AliAnalysisDataContainer *taskInputContainer;
	101	AliAnalysisDataContainer *taskOutputContainer;
	102	AliAnalysisTaskDptDptQA* task;
143d78d1	103
c5704d5c	104	TFile * inputFile = 0;
	105	TList * histoList = 0;
	106	TH3F * weight_1 = 0;
	107	TH3F * weight_2 = 0;
	108
	109	int iCentrality = centralitySelected;
	110	outputHistogramFileName = baseName;
	111	if (singlesOnly) outputHistogramFileName += singlesOnlySuffix;
	112	outputHistogramFileName += ".root";
143d78d1	113
c5704d5c	114	if (useWeights)
	115	{
	116	TGrid::Connect("alien:");
	117	inputFile = TFile::Open(inputHistogramFileName,"OLD");
	118	if (!inputFile)
	119	{
	120	cout << "Requested file:" << inputHistogramFileName << " was not opened. ABORT." << endl;
	121	return;
	122	}
	123	}
	124
	125	//============================
	126	// (+,+)
	127	//============================
	128	requestedCharge1 = 1;
	129	requestedCharge2 = 1;
	130	sameFilter = 1;
	131	part1Name = "P_";
	132	part1Name += trackFilterBit;
	133	part1Name += "_";
	134	part1Name += int(1000*etaMax);
	135	part1Name += "_";
	136	part1Name += int(1000*ptMin);
	137	part1Name += "pt";
	138	part1Name += int(1000*ptMax);
	139	part1Name += "_";
	140	part2Name = "P_";
	141	part2Name += int(1000*etaMax);
	142	part2Name += "_";
	143	part2Name += int(1000*ptMin);
	144	part2Name += "pt";
	145	part2Name += int(1000*ptMax);
	146	part2Name += "_";
	147	eventName = "";
	148	eventName += int(10.*minCentrality[iCentrality] );
	149	eventName += "Vo";
	150	eventName += int(10.*maxCentrality[iCentrality] );
	151	baseName = prefixName;
	152	baseName += part1Name;
	153	baseName += part2Name;
	154	baseName += eventName;
	155	listName = baseName;
	156	taskName = baseName;
	157	if (useWeights)
	158	{
	159	TString nameHistoBase = "correction_";
	160	TString nameHisto;
	161	nameHistoBase += eventName;
	162	nameHisto = nameHistoBase + "_p";
	163	cout << "Input Histogram named: " << nameHisto << endl;
	164	weight_1 = (TH3F *) inputFile->Get(nameHisto);
	165	weight_2 = weight_1;
	166	}
	167	else
	168	{
	169	weight_1 = 0;
	170	weight_2 = 0;
	171	}
	172	task = new AliAnalysisTaskDptDptQA(taskName);
	173	//configure my task
	174	task->SetDebugLevel( debugLevel );
	175	task->SetSameFilter( sameFilter );
	176	task->SetSinglesOnly( singlesOnly );
	177	task->SetUseWeights( useWeights );
178	task->SetRejectPileup( rejectPileup );
179	task->SetRejectPairConversion(rejectPairConversion);
180	task->SetVertexZMin( zMin );
181	task->SetVertexZMax( zMax );
182	task->SetVertexXYMin( -1. );
183	task->SetVertexXYMax( 1. );
184	task->SetCentralityMethod( centralityMethod);
185	task->SetCentrality( minCentrality[iCentrality], maxCentrality[iCentrality]);
186	task->SetPtMin1( ptMin );
187	task->SetPtMax1( ptMax );
188	task->SetEtaMin1( etaMin );
189	task->SetEtaMax1( etaMax );
190	task->SetPtMin2( ptMin );
191	task->SetPtMax2( ptMax );
192	task->SetEtaMin2( etaMin );
193	task->SetEtaMax2( etaMax );
194	task->SetDcaZMin( dcaZMin );
195	task->SetDcaZMax( dcaZMax );
196	task->SetDcaXYMin( dcaXYMin );
197	task->SetDcaXYMax( dcaXYMax );
198	task->SetDedxMin( dedxMin );
199	task->SetDedxMax( dedxMax );
200	task->SetNClusterMin( nClusterMin );
201	task->SetTrackFilterBit( trackFilterBit );
202	task->SetRequestedCharge_1( requestedCharge1);
203	task->SetRequestedCharge_2( requestedCharge2);
204	task->SetWeigth_1( weight_1 );
205	task->SetWeigth_2( weight_2 );
206
207
208	cout << "Creating task output container" << endl;
209	taskOutputContainer = analysisManager->CreateContainer(listName,
210	TList::Class(),
211	AliAnalysisManager::kOutputContainer,
212	Form("%s:Histos", AliAnalysisManager::GetCommonFileName()));
213	cout << "Add task to analysis manager and connect it to input and output containers" << endl;
214	analysisManager->AddTask(task);
215	analysisManager->ConnectInput( task, 0, analysisManager->GetCommonInputContainer());
216	analysisManager->ConnectOutput(task, 0, taskOutputContainer );
217	cout << "(+,+) Task added ...." << endl;
218
219	//============================
220	// (+,-)
221	//============================
222	requestedCharge1 = 1;
223	requestedCharge2 = -1;
224	sameFilter = 0;
225	part1Name = "P_";
226	part1Name += trackFilterBit;
227	part1Name += "_";
228	part1Name += int(1000*etaMax);
229	part1Name += "_";
230	part1Name += int(1000*ptMin);
231	part1Name += "pt";
232	part1Name += int(1000*ptMax);
233	part1Name += "_";
234	part2Name = "M_";
235	part2Name += trackFilterBit;
236	part2Name += int(1000*etaMax);
237	part2Name += "_";
238	part2Name += int(1000*ptMin);
239	part2Name += "pt";
240	part2Name += int(1000*ptMax);
241	part2Name += "_";
242	eventName = "";
243	eventName += int(10.*minCentrality[iCentrality] );
244	eventName += "Vo";
245	eventName += int(10.*maxCentrality[iCentrality] );
246	baseName = prefixName;
247	baseName += part1Name;
248	baseName += part2Name;
249	baseName += eventName;
250	listName = baseName;
251	taskName = baseName;
252	if (useWeights)
253	{
254	TString nameHistoBase = "correction_";
255	TString nameHisto;
256	nameHistoBase += eventName;
257	nameHisto = nameHistoBase + "_p";
258	cout << "Input Histogram named: " << nameHisto << endl;
259	weight_1 = (TH3F *) inputFile->Get(nameHisto);
260	nameHisto = nameHistoBase + "_m";
261	cout << "Input Histogram named: " << nameHisto << endl;
262	weight_2 = (TH3F *) inputFile->Get(nameHisto);
263	}
264	else
265	{
266	weight_1 = 0;
267	weight_2 = 0;
268	}
269	task = new AliAnalysisTaskDptDptQA(taskName);
270	//configure my task
271	task->SetDebugLevel( debugLevel );
272	task->SetSameFilter( sameFilter );
273	task->SetSinglesOnly( singlesOnly );
274	task->SetUseWeights( useWeights );
275	task->SetRejectPileup( rejectPileup );
276	task->SetRejectPairConversion(rejectPairConversion);
277	task->SetVertexZMin( zMin );
278	task->SetVertexZMax( zMax );
279	task->SetVertexXYMin( -1. );
280	task->SetVertexXYMax( 1. );
281	task->SetCentralityMethod( centralityMethod);
282	task->SetCentrality( minCentrality[iCentrality], maxCentrality[iCentrality]);
283	task->SetPtMin1( ptMin );
284	task->SetPtMax1( ptMax );
285	task->SetEtaMin1( etaMin );
286	task->SetEtaMax1( etaMax );
287	task->SetPtMin2( ptMin );
288	task->SetPtMax2( ptMax );
289	task->SetEtaMin2( etaMin );
290	task->SetEtaMax2( etaMax );
291	task->SetDcaZMin( dcaZMin );
292	task->SetDcaZMax( dcaZMax );
293	task->SetDcaXYMin( dcaXYMin );
294	task->SetDcaXYMax( dcaXYMax );
295	task->SetDedxMin( dedxMin );
296	task->SetDedxMax( dedxMax );
297	task->SetNClusterMin( nClusterMin );
298	task->SetTrackFilterBit( trackFilterBit );
299	task->SetRequestedCharge_1( requestedCharge1);
300	task->SetRequestedCharge_2( requestedCharge2);
301	task->SetWeigth_1( weight_1 );
302	task->SetWeigth_2( weight_2 );
303
304
305	cout << "Creating task output container" << endl;
306	taskOutputContainer = analysisManager->CreateContainer(listName,
307	TList::Class(),
308	AliAnalysisManager::kOutputContainer,
309	Form("%s:Histos", AliAnalysisManager::GetCommonFileName()));
310	cout << "Add task to analysis manager and connect it to input and output containers" << endl;
311	analysisManager->AddTask(task);
312	analysisManager->ConnectInput( task, 0, analysisManager->GetCommonInputContainer());
313	analysisManager->ConnectOutput(task, 0, taskOutputContainer );
314	cout << "Task added ...." << endl;
143d78d1	315
c5704d5c	316	//============================
	317	// (-,-)
	318	//============================
	319	requestedCharge1 = -1;
	320	requestedCharge2 = -1;
	321	sameFilter = 1;
	322	part1Name = "M_";
	323	part1Name += trackFilterBit;
	324	part1Name += "_";
	325	part1Name += int(1000*etaMax);
	326	part1Name += "_";
	327	part1Name += int(1000*ptMin);
	328	part1Name += "pt";
	329	part1Name += int(1000*ptMax);
	330	part1Name += "_";
	331	part2Name = "M_";
	332	part2Name += trackFilterBit;
	333	part2Name += int(1000*etaMax);
	334	part2Name += "_";
	335	part2Name += int(1000*ptMin);
	336	part2Name += "pt";
	337	part2Name += int(1000*ptMax);
	338	part2Name += "_";
	339	eventName = "";
	340	eventName += int(10.*minCentrality[iCentrality] );
	341	eventName += "Vo";
	342	eventName += int(10.*maxCentrality[iCentrality] );
	343	baseName = prefixName;
	344	baseName += part1Name;
	345	baseName += part2Name;
	346	baseName += eventName;
	347	listName = baseName;
	348	taskName = baseName;
	349	if (useWeights)
	350	{
	351	TString nameHistoBase = "correction_";
	352	TString nameHisto;
	353	nameHistoBase += eventName;
	354	nameHisto = nameHistoBase + "_m";
	355	cout << "Input Histogram named: " << nameHisto << endl;
	356	weight_1 = (TH3F *) inputFile->Get(nameHisto);
	357	weight_2 = weight_1;
	358	}
	359	else
	360	{
	361	weight_1 = 0;
	362	weight_2 = 0;
2542e3ae	363	}
c5704d5c	364	task = new AliAnalysisTaskDptDptQA(taskName);
	365	//configure my task
	366	task->SetDebugLevel( debugLevel );
	367	task->SetSameFilter( sameFilter );
	368	task->SetSinglesOnly( singlesOnly );
	369	task->SetUseWeights( useWeights );
	370	task->SetRejectPileup( rejectPileup );
	371	task->SetRejectPairConversion(rejectPairConversion);
	372	task->SetVertexZMin( zMin );
	373	task->SetVertexZMax( zMax );
	374	task->SetVertexXYMin( -1. );
	375	task->SetVertexXYMax( 1. );
	376	task->SetCentralityMethod( centralityMethod);
	377	task->SetCentrality( minCentrality[iCentrality], maxCentrality[iCentrality]);
	378	task->SetPtMin1( ptMin );
	379	task->SetPtMax1( ptMax );
	380	task->SetEtaMin1( etaMin );
	381	task->SetEtaMax1( etaMax );
	382	task->SetPtMin2( ptMin );
	383	task->SetPtMax2( ptMax );
	384	task->SetEtaMin2( etaMin );
	385	task->SetEtaMax2( etaMax );
	386	task->SetDcaZMin( dcaZMin );
	387	task->SetDcaZMax( dcaZMax );
	388	task->SetDcaXYMin( dcaXYMin );
	389	task->SetDcaXYMax( dcaXYMax );
	390	task->SetDedxMin( dedxMin );
	391	task->SetDedxMax( dedxMax );
	392	task->SetNClusterMin( nClusterMin );
	393	task->SetTrackFilterBit( trackFilterBit );
	394	task->SetRequestedCharge_1( requestedCharge1);
	395	task->SetRequestedCharge_2( requestedCharge2);
	396	task->SetWeigth_1( weight_1 );
	397	task->SetWeigth_2( weight_2 );
	398
2542e3ae	399
c5704d5c	400	cout << "Creating task output container" << endl;
	401	taskOutputContainer = analysisManager->CreateContainer(listName,
	402	TList::Class(),
	403	AliAnalysisManager::kOutputContainer,
	404	Form("%s:Histos", AliAnalysisManager::GetCommonFileName()));
	405	analysisManager->AddTask(task);
	406	analysisManager->ConnectInput( task, 0, analysisManager->GetCommonInputContainer());
	407	analysisManager->ConnectOutput(task, 0, taskOutputContainer );
2542e3ae	408	return task;
2542e3ae	409	}