[u/mrichter/AliRoot.git] / PWGCF / FEMTOSCOPY / macros / Train / FemtoQA / PbPb_MC / ConfigFemtoAnalysis.C

/*********************************************************************
 *																							 *
 * Configfemtoanalysis.C - configuration macro for the femtoscopic	 *
 * analysis, meant as a QA process for two-particle effects				 *
 *																							 *
 * Author: Adam Kisiel (Adam.Kisiel@cern.ch)									 *
 *																							 *
 *********************************************************************/

#if !defined(__CINT__) || defined(__MAKECINT_)
#include "AliFemtoManager.h"
#include "AliFemtoEventReaderESDChain.h"
#include "AliFemtoEventReaderESDChainKine.h"
#include "AliFemtoEventReaderAODChain.h"
#include "AliFemtoSimpleAnalysis.h"
#include "AliFemtoBasicEventCut.h"
#include "AliFemtoESDTrackCut.h"
#include "AliFemtoCorrFctn.h"
#include "AliFemtoCutMonitorParticleYPt.h"
#include "AliFemtoCutMonitorParticleVertPos.h"
#include "AliFemtoCutMonitorParticleMomRes.h"
#include "AliFemtoCutMonitorParticlePID.h"
#include "AliFemtoCutMonitorEventMult.h"
#include "AliFemtoCutMonitorEventVertex.h"
#include "AliFemtoShareQualityTPCEntranceSepPairCut.h"
#include "AliFemtoPairCutAntiGamma.h"
#include "AliFemtoPairCutRadialDistance.h"
#include "AliFemtoQinvCorrFctn.h"
#include "AliFemtoCorrFctnNonIdDR.h"
#include "AliFemtoShareQualityCorrFctn.h"
#include "AliFemtoTPCInnerCorrFctn.h"
#include "AliFemtoVertexMultAnalysis.h"
#include "AliFemtoCorrFctn3DSpherical.h"
#include "AliFemtoChi2CorrFctn.h"
#include "AliFemtoCorrFctnTPCNcls.h"
#include "AliFemtoBPLCMS3DCorrFctn.h"
#include "AliFemtoCorrFctn3DLCMSSym.h"
#include "AliFemtoModelBPLCMSCorrFctn.h"
#include "AliFemtoModelCorrFctn3DSpherical.h"
#include "AliFemtoModelGausLCMSFreezeOutGenerator.h"
#include "AliFemtoModelGausRinvFreezeOutGenerator.h"
#include "AliFemtoModelManager.h"
#include "AliFemtoModelWeightGeneratorBasic.h"
#include "AliFemtoModelWeightGeneratorLednicky.h"
#include "AliFemtoCorrFctnDirectYlm.h"
#include "AliFemtoModelCorrFctnDirectYlm.h"
#include "AliFemtoModelCorrFctnSource.h"
#include "AliFemtoCutMonitorParticlePtPDG.h"
#include "AliFemtoKTPairCut.h"
#include "AliFemtoPairCutPt.h"
#endif

//________________________________________________________________________
AliFemtoManager* ConfigFemtoAnalysis() {

	double PionMass = 0.13956995;
	double KaonMass = 0.493677;
	double ProtonMass = 0.938272013;

	const int numOfMultBins = 4;
	const int numOfChTypes = 3;
	const int numOfkTbins = 4;

	int runmults[numOfMultBins] = {1,0,0,0};
	int multbins[numOfMultBins+1] = {0.001, 100, 200, 400, 600};

	int runch[numOfChTypes] = {0, 1, 0};
	const char *chrgs[numOfChTypes] = { "pip", "pim", "pippim" };

	int runktdep[numOfkTbins] = {1,0,0,1};
	double ktrng[numOfkTbins+1] = {0.2, 0.3, 0.4, 0.6, 0.7};

	int gammacut = 0;	// cut na ee for gamma

	double shqmax = 0.5;
	int nbinssh = 200;

	//AliFemtoEventReaderESDChain *Reader = new AliFemtoEventReaderESDChain();
	//Reader->SetUseMultiplicity(AliFemtoEventReaderESDChain::kGlobalCount);

	AliFemtoEventReaderAODChain *Reader = new AliFemtoEventReaderAODChain();
	Reader->SetFilterBit(7);
  Reader->SetCentralityPreSelection(0.00001, 710);
  Reader->SetEPVZERO(kTRUE);
  Reader->SetCentralityFlattening(kTRUE);
  Reader->SetReadMC(kTRUE);

	AliFemtoManager* Manager = new AliFemtoManager();
	Manager->SetEventReader(Reader);

	AliFemtoVertexMultAnalysis		*anetaphitpc[320];
	AliFemtoBasicEventCut			 *mecetaphitpc[320];
	AliFemtoCutMonitorEventMult	 *cutPassEvMetaphitpc[320];
	AliFemtoCutMonitorEventMult	 *cutFailEvMetaphitpc[320];
	AliFemtoCutMonitorEventVertex  *cutPassEvVetaphitpc[320];
	AliFemtoCutMonitorEventVertex  *cutFailEvVetaphitpc[320];

	AliFemtoESDTrackCut		*dtc5etaphitpc[320];
	AliFemtoESDTrackCut		*dtc6etaphitpc[320];

	AliFemtoTPCInnerCorrFctn      *PhiStarEtaetaphitpc[320];

	AliFemtoCutMonitorParticleYPt *cutPass6YPtetaphitpc[320];
	AliFemtoCutMonitorParticleYPt *cutFail6YPtetaphitpc[320];
	AliFemtoCutMonitorParticlePID *cutPass6PIDetaphitpc[320];
	AliFemtoCutMonitorParticlePID *cutFail6PIDetaphitpc[320];
	//	 AliFemtoShareQualityTPCEntranceSepPairCut	*sqpcetaphitpcsame[320];
	AliFemtoPairCutAntiGamma			*sqpcetaphitpc[320];
	//	AliFemtoPairCutRadialDistance			*sqpcetaphitpc[320];
	//	AliFemtoChi2CorrFctn				*cchiqinvetaphitpc[320];
	AliFemtoKTPairCut				 *ktpcuts[320];
	AliFemtoQinvCorrFctn				*cqinvkttpc[320];
	AliFemtoQinvCorrFctn				*cqinvtpc[320];
	AliFemtoCorrFctnDEtaDPhi			*cdedpetaphi[320];


	// *** Third QA task - HBT analysis ***
	// *** Begin pion-pion analysis ***
	int aniter = 0;

	for (int imult = 0; imult < numOfMultBins; imult++)
	{
		if (runmults[imult])
		{
			for (int ichg = 0; ichg < numOfChTypes; ichg++)
			{
				if (runch[ichg])
				{

					aniter = ichg * numOfMultBins + imult;
					anetaphitpc[aniter] = new AliFemtoVertexMultAnalysis(8, -8.0, 8.0, 6, multbins[imult], multbins[imult+1]);
					anetaphitpc[aniter]->SetNumEventsToMix(10);
					anetaphitpc[aniter]->SetMinSizePartCollection(1);
          anetaphitpc[aniter]->SetVerboseMode(kFALSE);

					mecetaphitpc[aniter] = new AliFemtoBasicEventCut();
					mecetaphitpc[aniter]->SetEventMult(0.001,100000);
					mecetaphitpc[aniter]->SetVertZPos(-8,8);//cm

					// //*** Event monitors ***

					// cutPassEvMetaphitpc[aniter] = new AliFemtoCutMonitorEventMult(Form("cutPass%stpcM%i", chrgs[ichg], imult));
					// cutFailEvMetaphitpc[aniter] = new AliFemtoCutMonitorEventMult(Form("cutFail%stpcM%i", chrgs[ichg], imult));
					// mecetaphitpc[aniter]->AddCutMonitor(cutPassEvMetaphitpc[aniter], cutFailEvMetaphitpc[aniter]);

					// cutPassEvVetaphitpc[aniter] = new AliFemtoCutMonitorEventVertex(Form("cutPass%stpcM%i", chrgs[ichg], imult));
					// cutFailEvVetaphitpc[aniter] = new AliFemtoCutMonitorEventVertex(Form("cutFail%stpcM%i", chrgs[ichg], imult));
					// mecetaphitpc[aniter]->AddCutMonitor(cutPassEvVetaphitpc[aniter], cutFailEvVetaphitpc[aniter]);

					//*** Cuts ***

					dtc5etaphitpc[aniter] = new AliFemtoESDTrackCut();
					dtc6etaphitpc[aniter] = new AliFemtoESDTrackCut();

					dtc5etaphitpc[aniter]->SetCharge(1.0);
					dtc6etaphitpc[aniter]->SetCharge(-1.0);


					dtc5etaphitpc[aniter]->SetEta(-1.0,1.0);
					dtc5etaphitpc[aniter]->SetPt(0.2,20);
					dtc5etaphitpc[aniter]->SetMass(PionMass);
					dtc5etaphitpc[aniter]->SetMostProbablePion();

					dtc6etaphitpc[aniter]->SetEta(-1.0,1.0);
					dtc6etaphitpc[aniter]->SetPt(0.2,20);
					dtc6etaphitpc[aniter]->SetMass(PionMass);
					dtc6etaphitpc[aniter]->SetMostProbablePion();

					// Track quality cuts

					dtc5etaphitpc[aniter]->SetStatus(AliESDtrack::kTPCin);
					dtc5etaphitpc[aniter]->SetminTPCncls(80);
					dtc5etaphitpc[aniter]->SetRemoveKinks(kTRUE);
					dtc5etaphitpc[aniter]->SetLabel(kFALSE);
					//	dtc5etaphitpc[aniter]->SetMaxITSChiNdof(6.0);
					dtc5etaphitpc[aniter]->SetMaxTPCChiNdof(4.0);
					dtc5etaphitpc[aniter]->SetMaxImpactXYPtDep(0.018, 0.035, -1.01) ;
					//	dtc5etaphitpc[aniter]->SetMaxImpactXYPtDep(0.0182, 0.0350, -1.01);
					dtc5etaphitpc[aniter]->SetMaxImpactZ(2);
					//	dtc5etaphitpc[aniter]->SetMaxSigmaToVertex(6.0);


					dtc6etaphitpc[aniter]->SetStatus(AliESDtrack::kTPCin);
					dtc6etaphitpc[aniter]->SetminTPCncls(80);
					dtc6etaphitpc[aniter]->SetRemoveKinks(kTRUE);
					dtc6etaphitpc[aniter]->SetLabel(kFALSE);
					//      dtc6etaphitpc[aniter]->SetMaxITSChiNdof(6.0);
					dtc6etaphitpc[aniter]->SetMaxTPCChiNdof(4.0);
					dtc6etaphitpc[aniter]->SetMaxImpactXYPtDep(0.018, 0.035, -1.01) ;
					//      dtc6etaphitpc[aniter]->SetMaxImpactXYPtDep(0.0182, 0.0350, -1.01);
					dtc6etaphitpc[aniter]->SetMaxImpactZ(2);
					//      dtc6etaphitpc[aniter]->SetMaxSigmaToVertex(6.0);

					// //*** Single track monitors ***

					// cutPass6YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutPass%stpcM%i", chrgs[ichg], imult),PionMass);
					// cutFail6YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutFail%stpcM%i", chrgs[ichg], imult),PionMass);
					// dtc5etaphitpc[aniter]->AddCutMonitor(cutPass6YPtetaphitpc[aniter], cutFail6YPtetaphitpc[aniter]);

					// cutPass6PIDetaphitpc[aniter] = new AliFemtoCutMonitorParticlePID(Form("cutPass%stpcM%i", chrgs[ichg], imult),0);//0-pion,1-kaon,2-proton
					// cutFail6PIDetaphitpc[aniter] = new AliFemtoCutMonitorParticlePID(Form("cutFail%stpcM%i", chrgs[ichg], imult),0);
					// dtc5etaphitpc[aniter]->AddCutMonitor(cutPass6PIDetaphitpc[aniter], cutFail6PIDetaphitpc[aniter]);


					//*** Two-track cuts monitors ***
					sqpcetaphitpc[aniter] = new AliFemtoPairCutAntiGamma();

					sqpcetaphitpc[aniter]->SetShareQualityMax(1.0);	// two track cuts on splitting and merging
					sqpcetaphitpc[aniter]->SetShareFractionMax(0.05);
					sqpcetaphitpc[aniter]->SetRemoveSameLabel(kFALSE);

					if (gammacut == 0)
          {
            sqpcetaphitpc[aniter]->SetMaxEEMinv(0.0);
            sqpcetaphitpc[aniter]->SetMaxThetaDiff(0.0);
          }
					else if (gammacut == 1)
          {
            sqpcetaphitpc[aniter]->SetMaxEEMinv(0.002);
            sqpcetaphitpc[aniter]->SetMaxThetaDiff(0.008);
          }

					anetaphitpc[aniter]->SetEventCut(mecetaphitpc[aniter]);

					if(ichg==0)//pip
					{
						anetaphitpc[aniter]->SetFirstParticleCut(dtc5etaphitpc[aniter]);
						anetaphitpc[aniter]->SetSecondParticleCut(dtc5etaphitpc[aniter]);
					}
					if(ichg==1)//pim
					{
						anetaphitpc[aniter]->SetFirstParticleCut(dtc6etaphitpc[aniter]);
						anetaphitpc[aniter]->SetSecondParticleCut(dtc6etaphitpc[aniter]);

					}
					if(ichg==2)//pip pim
					{
						anetaphitpc[aniter]->SetFirstParticleCut(dtc5etaphitpc[aniter]);
						anetaphitpc[aniter]->SetSecondParticleCut(dtc6etaphitpc[aniter]);
					}

					anetaphitpc[aniter]->SetPairCut(sqpcetaphitpc[aniter]);

					// *** Correlation functions ***

					// //Deta-Dphi correlation function
					// cdedpetaphi[aniter] = new AliFemtoCorrFctnDEtaDPhi(Form("cdedp%stpcM%i", chrgs[ichg], imult),35, 35);

					// //qinv correlation function
					// cqinvtpc[aniter] = new AliFemtoQinvCorrFctn(Form("cqinv%stpcM%i", chrgs[ichg], imult),nbinssh,0.0,2.0);
					// anetaphitpc[aniter]->AddCorrFctn(cqinvtpc[aniter]);

					// //Phi*-Eta monitor
					// PhiStarEtaetaphitpc[aniter] = new AliFemtoTPCInnerCorrFctn(Form("PhistarEta%stpcM%i", chrgs[ichg], imult),nbinssh,0.0,2.0);
					// anetaphitpc[aniter]->AddCorrFctn(PhiStarEtaetaphitpc[aniter]);

          int ktm;
          for (int ikt=0; ikt<numOfkTbins; ikt++)
          {
            if (runktdep[ikt])
            {

							ktm = aniter * numOfkTbins + ikt;
							ktpcuts[ktm] = new AliFemtoKTPairCut(ktrng[ikt], ktrng[ikt+1]);

							cqinvkttpc[ktm] = new AliFemtoQinvCorrFctn(Form("cqinv%stpcM%ikT%i", chrgs[ichg], imult, ikt),nbinssh,0.0,2.0);
							cqinvkttpc[ktm]->SetPairSelectionCut(ktpcuts[ktm]);
							anetaphitpc[aniter]->AddCorrFctn(cqinvkttpc[ktm]);

							PhiStarEtaetaphitpc[aniter] = new AliFemtoTPCInnerCorrFctn(Form("PhistarEta%stpcM%ikT%i", chrgs[ichg], imult, ikt),nbinssh,0.0,shqmax);
							anetaphitpc[aniter]->AddCorrFctn(PhiStarEtaetaphitpc[aniter]);

						}
					}
          Manager->AddAnalysis(anetaphitpc[aniter]);

				}

			}
		}
	}
	// *** End pion-pion (positive) analysis

	return Manager;
}
Commit	Line	Data
4b5f5617	1	/*********************************************************************
	2	* *
	3	* Configfemtoanalysis.C - configuration macro for the femtoscopic *
	4	* analysis, meant as a QA process for two-particle effects *
	5	* *
	6	* Author: Adam Kisiel (Adam.Kisiel@cern.ch) *
	7	* *
	8	*********************************************************************/
	9
	10	#if !defined(__CINT__) \|\| defined(__MAKECINT_)
	11	#include "AliFemtoManager.h"
	12	#include "AliFemtoEventReaderESDChain.h"
	13	#include "AliFemtoEventReaderESDChainKine.h"
	14	#include "AliFemtoEventReaderAODChain.h"
	15	#include "AliFemtoSimpleAnalysis.h"
	16	#include "AliFemtoBasicEventCut.h"
	17	#include "AliFemtoESDTrackCut.h"
	18	#include "AliFemtoCorrFctn.h"
	19	#include "AliFemtoCutMonitorParticleYPt.h"
	20	#include "AliFemtoCutMonitorParticleVertPos.h"
	21	#include "AliFemtoCutMonitorParticleMomRes.h"
	22	#include "AliFemtoCutMonitorParticlePID.h"
	23	#include "AliFemtoCutMonitorEventMult.h"
	24	#include "AliFemtoCutMonitorEventVertex.h"
	25	#include "AliFemtoShareQualityTPCEntranceSepPairCut.h"
	26	#include "AliFemtoPairCutAntiGamma.h"
	27	#include "AliFemtoPairCutRadialDistance.h"
	28	#include "AliFemtoQinvCorrFctn.h"
	29	#include "AliFemtoCorrFctnNonIdDR.h"
	30	#include "AliFemtoShareQualityCorrFctn.h"
	31	#include "AliFemtoTPCInnerCorrFctn.h"
	32	#include "AliFemtoVertexMultAnalysis.h"
	33	#include "AliFemtoCorrFctn3DSpherical.h"
	34	#include "AliFemtoChi2CorrFctn.h"
	35	#include "AliFemtoCorrFctnTPCNcls.h"
	36	#include "AliFemtoBPLCMS3DCorrFctn.h"
	37	#include "AliFemtoCorrFctn3DLCMSSym.h"
	38	#include "AliFemtoModelBPLCMSCorrFctn.h"
	39	#include "AliFemtoModelCorrFctn3DSpherical.h"
	40	#include "AliFemtoModelGausLCMSFreezeOutGenerator.h"
	41	#include "AliFemtoModelGausRinvFreezeOutGenerator.h"
	42	#include "AliFemtoModelManager.h"
	43	#include "AliFemtoModelWeightGeneratorBasic.h"
	44	#include "AliFemtoModelWeightGeneratorLednicky.h"
	45	#include "AliFemtoCorrFctnDirectYlm.h"
	46	#include "AliFemtoModelCorrFctnDirectYlm.h"
	47	#include "AliFemtoModelCorrFctnSource.h"
	48	#include "AliFemtoCutMonitorParticlePtPDG.h"
	49	#include "AliFemtoKTPairCut.h"
	50	#include "AliFemtoPairCutPt.h"
	51	#endif
	52
	53	//________________________________________________________________________
	54	AliFemtoManager* ConfigFemtoAnalysis() {
	55
	56	double PionMass = 0.13956995;
	57	double KaonMass = 0.493677;
	58	double ProtonMass = 0.938272013;
	59
	60	const int numOfMultBins = 4;
	61	const int numOfChTypes = 3;
	62	const int numOfkTbins = 4;
	63
	64	int runmults[numOfMultBins] = {1,0,0,0};
65	int multbins[numOfMultBins+1] = {0.001, 100, 200, 400, 600};
66
67	int runch[numOfChTypes] = {0, 1, 0};
68	const char *chrgs[numOfChTypes] = { "pip", "pim", "pippim" };
69
70	int runktdep[numOfkTbins] = {1,0,0,1};
893ed0c9	71	double ktrng[numOfkTbins+1] = {0.2, 0.3, 0.4, 0.6, 0.7};
4b5f5617	72
	73	int gammacut = 0; // cut na ee for gamma
	74
	75	double shqmax = 0.5;
	76	int nbinssh = 200;
	77
	78	//AliFemtoEventReaderESDChain *Reader = new AliFemtoEventReaderESDChain();
	79	//Reader->SetUseMultiplicity(AliFemtoEventReaderESDChain::kGlobalCount);
	80
	81	AliFemtoEventReaderAODChain *Reader = new AliFemtoEventReaderAODChain();
	82	Reader->SetFilterBit(7);
	83	Reader->SetCentralityPreSelection(0.00001, 710);
	84	Reader->SetEPVZERO(kTRUE);
	85	Reader->SetCentralityFlattening(kTRUE);
	86	Reader->SetReadMC(kTRUE);
	87
	88	AliFemtoManager* Manager = new AliFemtoManager();
	89	Manager->SetEventReader(Reader);
	90
	91	AliFemtoVertexMultAnalysis *anetaphitpc[320];
	92	AliFemtoBasicEventCut *mecetaphitpc[320];
	93	AliFemtoCutMonitorEventMult *cutPassEvMetaphitpc[320];
	94	AliFemtoCutMonitorEventMult *cutFailEvMetaphitpc[320];
	95	AliFemtoCutMonitorEventVertex *cutPassEvVetaphitpc[320];
	96	AliFemtoCutMonitorEventVertex *cutFailEvVetaphitpc[320];
	97
	98	AliFemtoESDTrackCut *dtc5etaphitpc[320];
	99	AliFemtoESDTrackCut *dtc6etaphitpc[320];
	100
	101	AliFemtoTPCInnerCorrFctn *PhiStarEtaetaphitpc[320];
	102
	103	AliFemtoCutMonitorParticleYPt *cutPass6YPtetaphitpc[320];
	104	AliFemtoCutMonitorParticleYPt *cutFail6YPtetaphitpc[320];
	105	AliFemtoCutMonitorParticlePID *cutPass6PIDetaphitpc[320];
	106	AliFemtoCutMonitorParticlePID *cutFail6PIDetaphitpc[320];
	107	// AliFemtoShareQualityTPCEntranceSepPairCut *sqpcetaphitpcsame[320];
	108	AliFemtoPairCutAntiGamma *sqpcetaphitpc[320];
	109	// AliFemtoPairCutRadialDistance *sqpcetaphitpc[320];
	110	// AliFemtoChi2CorrFctn *cchiqinvetaphitpc[320];
	111	AliFemtoKTPairCut *ktpcuts[320];
	112	AliFemtoQinvCorrFctn *cqinvkttpc[320];
	113	AliFemtoQinvCorrFctn *cqinvtpc[320];
	114	AliFemtoCorrFctnDEtaDPhi *cdedpetaphi[320];
	115
	116
	117
	118	// * Third QA task - HBT analysis *
	119	// * Begin pion-pion analysis *
	120	int aniter = 0;
	121
	122	for (int imult = 0; imult < numOfMultBins; imult++)
	123	{
	124	if (runmults[imult])
	125	{
	126	for (int ichg = 0; ichg < numOfChTypes; ichg++)
	127	{
	128	if (runch[ichg])
	129	{
	130
	131	aniter = ichg * numOfMultBins + imult;
	132	anetaphitpc[aniter] = new AliFemtoVertexMultAnalysis(8, -8.0, 8.0, 6, multbins[imult], multbins[imult+1]);
	133	anetaphitpc[aniter]->SetNumEventsToMix(10);
	134	anetaphitpc[aniter]->SetMinSizePartCollection(1);
	135	anetaphitpc[aniter]->SetVerboseMode(kFALSE);
136
137	mecetaphitpc[aniter] = new AliFemtoBasicEventCut();
138	mecetaphitpc[aniter]->SetEventMult(0.001,100000);
139	mecetaphitpc[aniter]->SetVertZPos(-8,8);//cm
140
141	// //* Event monitors *
142
143	// cutPassEvMetaphitpc[aniter] = new AliFemtoCutMonitorEventMult(Form("cutPass%stpcM%i", chrgs[ichg], imult));
144	// cutFailEvMetaphitpc[aniter] = new AliFemtoCutMonitorEventMult(Form("cutFail%stpcM%i", chrgs[ichg], imult));
145	// mecetaphitpc[aniter]->AddCutMonitor(cutPassEvMetaphitpc[aniter], cutFailEvMetaphitpc[aniter]);
146
147	// cutPassEvVetaphitpc[aniter] = new AliFemtoCutMonitorEventVertex(Form("cutPass%stpcM%i", chrgs[ichg], imult));
148	// cutFailEvVetaphitpc[aniter] = new AliFemtoCutMonitorEventVertex(Form("cutFail%stpcM%i", chrgs[ichg], imult));
149	// mecetaphitpc[aniter]->AddCutMonitor(cutPassEvVetaphitpc[aniter], cutFailEvVetaphitpc[aniter]);
150
151	//* Cuts *
152
153	dtc5etaphitpc[aniter] = new AliFemtoESDTrackCut();
154	dtc6etaphitpc[aniter] = new AliFemtoESDTrackCut();
155
156	dtc5etaphitpc[aniter]->SetCharge(1.0);
157	dtc6etaphitpc[aniter]->SetCharge(-1.0);
158
159
160	dtc5etaphitpc[aniter]->SetEta(-1.0,1.0);
161	dtc5etaphitpc[aniter]->SetPt(0.2,20);
162	dtc5etaphitpc[aniter]->SetMass(PionMass);
163	dtc5etaphitpc[aniter]->SetMostProbablePion();
164
165	dtc6etaphitpc[aniter]->SetEta(-1.0,1.0);
166	dtc6etaphitpc[aniter]->SetPt(0.2,20);
167	dtc6etaphitpc[aniter]->SetMass(PionMass);
168	dtc6etaphitpc[aniter]->SetMostProbablePion();
169
170	// Track quality cuts
171
172	dtc5etaphitpc[aniter]->SetStatus(AliESDtrack::kTPCin);
173	dtc5etaphitpc[aniter]->SetminTPCncls(80);
174	dtc5etaphitpc[aniter]->SetRemoveKinks(kTRUE);
175	dtc5etaphitpc[aniter]->SetLabel(kFALSE);
176	// dtc5etaphitpc[aniter]->SetMaxITSChiNdof(6.0);
177	dtc5etaphitpc[aniter]->SetMaxTPCChiNdof(4.0);
178	dtc5etaphitpc[aniter]->SetMaxImpactXYPtDep(0.018, 0.035, -1.01) ;
179	// dtc5etaphitpc[aniter]->SetMaxImpactXYPtDep(0.0182, 0.0350, -1.01);
180	dtc5etaphitpc[aniter]->SetMaxImpactZ(2);
181	// dtc5etaphitpc[aniter]->SetMaxSigmaToVertex(6.0);
182
183
184	dtc6etaphitpc[aniter]->SetStatus(AliESDtrack::kTPCin);
185	dtc6etaphitpc[aniter]->SetminTPCncls(80);
186	dtc6etaphitpc[aniter]->SetRemoveKinks(kTRUE);
187	dtc6etaphitpc[aniter]->SetLabel(kFALSE);
188	// dtc6etaphitpc[aniter]->SetMaxITSChiNdof(6.0);
189	dtc6etaphitpc[aniter]->SetMaxTPCChiNdof(4.0);
190	dtc6etaphitpc[aniter]->SetMaxImpactXYPtDep(0.018, 0.035, -1.01) ;
191	// dtc6etaphitpc[aniter]->SetMaxImpactXYPtDep(0.0182, 0.0350, -1.01);
192	dtc6etaphitpc[aniter]->SetMaxImpactZ(2);
193	// dtc6etaphitpc[aniter]->SetMaxSigmaToVertex(6.0);
194
195	// //* Single track monitors *
196
197	// cutPass6YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutPass%stpcM%i", chrgs[ichg], imult),PionMass);
198	// cutFail6YPtetaphitpc[aniter] = new AliFemtoCutMonitorParticleYPt(Form("cutFail%stpcM%i", chrgs[ichg], imult),PionMass);
199	// dtc5etaphitpc[aniter]->AddCutMonitor(cutPass6YPtetaphitpc[aniter], cutFail6YPtetaphitpc[aniter]);
200
201	// cutPass6PIDetaphitpc[aniter] = new AliFemtoCutMonitorParticlePID(Form("cutPass%stpcM%i", chrgs[ichg], imult),0);//0-pion,1-kaon,2-proton
202	// cutFail6PIDetaphitpc[aniter] = new AliFemtoCutMonitorParticlePID(Form("cutFail%stpcM%i", chrgs[ichg], imult),0);
203	// dtc5etaphitpc[aniter]->AddCutMonitor(cutPass6PIDetaphitpc[aniter], cutFail6PIDetaphitpc[aniter]);
204
205
206	//* Two-track cuts monitors *
207	sqpcetaphitpc[aniter] = new AliFemtoPairCutAntiGamma();
208
209	sqpcetaphitpc[aniter]->SetShareQualityMax(1.0); // two track cuts on splitting and merging
210	sqpcetaphitpc[aniter]->SetShareFractionMax(0.05);
211	sqpcetaphitpc[aniter]->SetRemoveSameLabel(kFALSE);
212
213	if (gammacut == 0)
214	{
215	sqpcetaphitpc[aniter]->SetMaxEEMinv(0.0);
216	sqpcetaphitpc[aniter]->SetMaxThetaDiff(0.0);
217	}
218	else if (gammacut == 1)
219	{
220	sqpcetaphitpc[aniter]->SetMaxEEMinv(0.002);
221	sqpcetaphitpc[aniter]->SetMaxThetaDiff(0.008);
222	}
223
224	anetaphitpc[aniter]->SetEventCut(mecetaphitpc[aniter]);
225
226	if(ichg==0)//pip
227	{
228	anetaphitpc[aniter]->SetFirstParticleCut(dtc5etaphitpc[aniter]);
229	anetaphitpc[aniter]->SetSecondParticleCut(dtc5etaphitpc[aniter]);
230	}
231	if(ichg==1)//pim
232	{
233	anetaphitpc[aniter]->SetFirstParticleCut(dtc6etaphitpc[aniter]);
234	anetaphitpc[aniter]->SetSecondParticleCut(dtc6etaphitpc[aniter]);
235
236	}
237	if(ichg==2)//pip pim
238	{
239	anetaphitpc[aniter]->SetFirstParticleCut(dtc5etaphitpc[aniter]);
240	anetaphitpc[aniter]->SetSecondParticleCut(dtc6etaphitpc[aniter]);
241	}
242
243	anetaphitpc[aniter]->SetPairCut(sqpcetaphitpc[aniter]);
244
245	// * Correlation functions *
246
247	// //Deta-Dphi correlation function
248	// cdedpetaphi[aniter] = new AliFemtoCorrFctnDEtaDPhi(Form("cdedp%stpcM%i", chrgs[ichg], imult),35, 35);
249
250	// //qinv correlation function
251	// cqinvtpc[aniter] = new AliFemtoQinvCorrFctn(Form("cqinv%stpcM%i", chrgs[ichg], imult),nbinssh,0.0,2.0);
252	// anetaphitpc[aniter]->AddCorrFctn(cqinvtpc[aniter]);
253
254	// //Phi*-Eta monitor
255	// PhiStarEtaetaphitpc[aniter] = new AliFemtoTPCInnerCorrFctn(Form("PhistarEta%stpcM%i", chrgs[ichg], imult),nbinssh,0.0,2.0);
256	// anetaphitpc[aniter]->AddCorrFctn(PhiStarEtaetaphitpc[aniter]);
257
258	int ktm;
259	for (int ikt=0; ikt<numOfkTbins; ikt++)
260	{
261	if (runktdep[ikt])
262	{
263
264	ktm = aniter * numOfkTbins + ikt;
265	ktpcuts[ktm] = new AliFemtoKTPairCut(ktrng[ikt], ktrng[ikt+1]);
266
267	cqinvkttpc[ktm] = new AliFemtoQinvCorrFctn(Form("cqinv%stpcM%ikT%i", chrgs[ichg], imult, ikt),nbinssh,0.0,2.0);
268	cqinvkttpc[ktm]->SetPairSelectionCut(ktpcuts[ktm]);
269	anetaphitpc[aniter]->AddCorrFctn(cqinvkttpc[ktm]);
270
893ed0c9	271	PhiStarEtaetaphitpc[aniter] = new AliFemtoTPCInnerCorrFctn(Form("PhistarEta%stpcM%ikT%i", chrgs[ichg], imult, ikt),nbinssh,0.0,shqmax);
4b5f5617	272	anetaphitpc[aniter]->AddCorrFctn(PhiStarEtaetaphitpc[aniter]);
	273
	274	}
	275	}
	276	Manager->AddAnalysis(anetaphitpc[aniter]);
	277
	278	}
	279
	280	}
	281	}
	282	}
	283	// *** End pion-pion (positive) analysis
	284
	285	return Manager;
	286	}