/////////////////////////////////////////////////////////////////////////////////////////////
// Define the range for eta subevents (for SP method)
+//-----(FMD 1.7 - 5.0)-----
+//Double_t minA = -5.0;
+//Double_t maxA = -1.7;
+//Double_t minB = 1.7;
+//Double_t maxB = 5.0;
+//-----(Tracklets 0.9 - 2.0)-----
+//Double_t minA = -2.0;
+//Double_t maxA = -0.9;
+//Double_t minB = 0.9;
+//Double_t maxB = 2.0;
+//-----(Global 0.5 - 0.9)-----
Double_t minA = -0.9;
-Double_t maxA = -0.01;
-Double_t minB = 0.01;
+Double_t maxA = -0.5;
+Double_t minB = 0.5;
Double_t maxB = 0.9;
+
// use physics selection class
Bool_t UsePhysicsSelection = kTRUE;
const Int_t multmaxESD = 1000000; //used for CORRFW cuts
Bool_t requireVtxCuts = kTRUE;
-Double_t vertexXmin = -1.0;
-Double_t vertexXmax = 1.0;
-Double_t vertexYmin = -1.0;
-Double_t vertexYmax = 1.0;
-Double_t vertexZmin = -15.0; //-1.e99;
-Double_t vertexZmax = 15.0; //1.e99;
+const Double_t vertexXmin = -1.e99;
+const Double_t vertexXmax = 1.e99;
+const Double_t vertexYmin = -1.e99;
+const Double_t vertexYmax = 1.e99;
+const Double_t vertexZmin = -1.e99;
+const Double_t vertexZmax = 1.e99;
+const Int_t vertexNContributorsmin = 1;
+const Int_t vertexNContributorsmax = 10000;
//Bool_t UseMultCut = kFALSE;
Bool_t UseMultCut = kTRUE;
-const Int_t multmin = 10; //used for AliFlowEventSimple (to set the centrality)
+const Int_t multmin = 1; //used for AliFlowEventSimple (to set the centrality)
const Int_t multmax = 10000; //used for AliFlowEventSimple (to set the centrality)
//const Int_t multmin = 10; //used for AliFlowEventSimple (to set the centrality)
//const Int_t multmax = 1000000; //used for AliFlowEventSimple (to set the centrality)
//----------For RP selection----------
+// Use Global tracks ("Global"), or SPD tracklets ("Tracklet")
+// or FMD hits ("FMD") for the RP selection
+const TString rptype = "Global";
+//const TString rptype = "Tracklet";
+//const TString rptype = "FMD";
+
//KINEMATICS (on generated and reconstructed tracks)
Bool_t UseKineforRP = kTRUE;
const Double_t ptminRP = 0.0;
const Double_t etaminRP = -0.9;
const Double_t etamaxRP = 0.9;
const Int_t chargeRP = 1; //not used
+const Bool_t isChargedRP = kTRUE;
//PID (on generated and reconstructed tracks)
Bool_t UsePIDforRP = kFALSE;
//see /CORRFW/AliCFTrackQualityCuts class
Bool_t UseTrackQualityforRP = kTRUE;
const Int_t minClustersTpcRP = 80; //default = -1;
-const Double_t maxChi2PerClusterTpcRP = 3.5; //default = 1.e+09;
+const Double_t maxChi2PerClusterTpcRP = 4.0; //default = 1.e+09;
const UShort_t minDedxClusterTpcRP = 0;
const Int_t minClustersItsRP = 2; //panos
const Double_t maxChi2PerClusterItsRP = 1.e+09;
Bool_t UseKineforPOI = kTRUE;
const Double_t ptminPOI = 0.0;
const Double_t ptmaxPOI = 10.0;
-const Double_t etaminPOI = -0.9;
-const Double_t etamaxPOI = 0.9;
+const Double_t etaminPOI = -0.5;
+const Double_t etamaxPOI = 0.5;
const Int_t chargePOI = 1; //not used
+const Bool_t isChargedPOI = kTRUE;
//PID (on generated and reconstructed tracks)
Bool_t UsePIDforPOI = kFALSE;
//see /CORRFW/AliCFTrackQualityCuts class
Bool_t UseTrackQualityforPOI = kTRUE;
const Int_t minClustersTpcPOI = 80;
-const Double_t maxChi2PerClusterTpcPOI = 3.5;
+const Double_t maxChi2PerClusterTpcPOI = 4.0;
const UShort_t minDedxClusterTpcPOI = 0;
const Int_t minClustersItsPOI = 2;
const Double_t maxChi2PerClusterItsPOI = 1.e+09;
Bool_t GFC = METHODS[6];
Bool_t QC = METHODS[7];
Bool_t FQD = METHODS[8];
- Bool_t MCEP = METHODS[9];
-
+ Bool_t MCEP = METHODS[9];
+ Bool_t MH = METHODS[10];
+ Bool_t NL = METHODS[11];
//for using weights
Bool_t useWeights = WEIGHTS[0] || WEIGHTS[1] || WEIGHTS[2];
if (useWeights) cout<<"Weights are used"<<endl;
cout<<"LYZEP input file/list read..."<<endl;
}
-
+
+ // Create the FMD task and add it to the manager
+ //===========================================================================
+ if (rptype == "FMD") {
+ AliFMDAnalysisTaskSE *taskfmd = NULL;
+ if (rptype == "FMD") {
+ taskfmd = new AliFMDAnalysisTaskSE("TaskFMD");
+ mgr->AddTask(taskfmd);
+
+ AliFMDAnaParameters* pars = AliFMDAnaParameters::Instance();
+ pars->Init();
+ pars->SetProcessPrimary(kTRUE);
+ pars->SetProcessHits(kFALSE);
+ }
+ }
+
// Create the task, add it to the manager.
//===========================================================================
AliAnalysisTaskFlowEvent *taskFE = NULL;
if (QA) {
if(AddToEvent) {
- taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kTRUE,1);
+ taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",rptype,kTRUE,1);
taskFE->SetEllipticFlowValue(ellipticFlow); } //TEST
- else {taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kTRUE); }
+ else {taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",rptype,kTRUE); }
taskFE->SetAnalysisType(type);
+ taskFE->SetRPType(rptype); //only for ESD
if (UseMultCut) {
taskFE->SetMinMult(multmin);
taskFE->SetMaxMult(multmax);
}
else {
if(AddToEvent) {
- taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kFALSE,1);
+ taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",rptype,kFALSE,1);
taskFE->SetEllipticFlowValue(ellipticFlow); } //TEST
- else {taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kFALSE); }
+ else {taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",rptype,kFALSE); }
taskFE->SetAnalysisType(type);
if (UseMultCut) {
taskFE->SetMinMult(multmin);
recEventCuts->SetVertexXCut(vertexXmin, vertexXmax);
recEventCuts->SetVertexYCut(vertexYmin, vertexYmax);
recEventCuts->SetVertexZCut(vertexZmin, vertexZmax);
+ recEventCuts->SetVertexNContributors(vertexNContributorsmin,vertexNContributorsmax);
if (QA) {
recEventCuts->SetQAOn(qaRP);
}
mcKineCutsRP->SetPtRange(ptminRP,ptmaxRP);
mcKineCutsRP->SetEtaRange(etaminRP,etamaxRP);
//mcKineCutsRP->SetChargeMC(chargeRP);
+ mcKineCutsRP->SetRequireIsCharged(isChargedRP);
if (QA) {
mcKineCutsRP->SetQAOn(qaRP);
}
recKineCutsRP->SetPtRange(ptminRP,ptmaxRP);
recKineCutsRP->SetEtaRange(etaminRP,etamaxRP);
//recKineCutsRP->SetChargeRec(chargeRP);
+ recKineCutsRP->SetRequireIsCharged(isChargedRP);
if (QA) {
recKineCutsRP->SetQAOn(qaRP);
}
mcKineCutsPOI->SetPtRange(ptminPOI,ptmaxPOI);
mcKineCutsPOI->SetEtaRange(etaminPOI,etamaxPOI);
//mcKineCutsPOI->SetChargeMC(chargePOI);
+ mcKineCutsPOI->SetRequireIsCharged(isChargedPOI);
if (QA) {
mcKineCutsPOI->SetQAOn(qaPOI);
}
recKineCutsPOI->SetPtRange(ptminPOI,ptmaxPOI);
recKineCutsPOI->SetEtaRange(etaminPOI,etamaxPOI);
//recKineCutsPOI->SetChargeRec(chargePOI);
+ recKineCutsPOI->SetRequireIsCharged(isChargedPOI);
if (QA) {
recKineCutsPOI->SetQAOn(qaPOI);
}
printf("CREATE ESD RECONSTRUCTION CUTS\n");
TObjArray* recListRP = new TObjArray(0) ;
- if (UseKineforRP) recListRP->AddLast(recKineCutsRP); //cut on pt/eta/phi
- if (UseTrackQualityforRP) recListRP->AddLast(recQualityCutsRP);
+ if (UseTrackQualityforRP) recListRP->AddLast(recQualityCutsRP); //track quality
if (UsePrimariesforRP) recListRP->AddLast(recIsPrimaryCutsRP); //cut if it is a primary
-
+ if (UseKineforRP) recListRP->AddLast(recKineCutsRP); //cut on pt/eta/phi
+
TObjArray* recListPOI = new TObjArray(0) ;
- if (UseKineforPOI) recListPOI->AddLast(recKineCutsPOI); //cut on pt/eta/phi
- if (UseTrackQualityforPOI) recListPOI->AddLast(recQualityCutsPOI);
+ if (UseTrackQualityforPOI) recListPOI->AddLast(recQualityCutsPOI); //track quality
if (UsePrimariesforPOI) recListPOI->AddLast(recIsPrimaryCutsPOI); //cut if it is a primary
-
+ if (UseKineforPOI) recListPOI->AddLast(recKineCutsPOI); //cut on pt/eta/phi
+
printf("CREATE ESD PID CUTS\n");
TObjArray* fPIDCutListRP = new TObjArray(0) ;
if(UsePIDforRP) {fPIDCutListRP->AddLast(cutPidRP);} //cut on ESD PID
//===========================================================================
if (SP){
AliAnalysisTaskScalarProduct *taskSP = new AliAnalysisTaskScalarProduct("TaskScalarProduct",WEIGHTS[0]);
+ taskSP->SetRelDiffMsub(1.0);
+ taskSP->SetApplyCorrectionForNUA(kFALSE);
mgr->AddTask(taskSP);
}
if (LYZ1SUM){
taskQC->SetUsePhiWeights(WEIGHTS[0]);
taskQC->SetUsePtWeights(WEIGHTS[1]);
taskQC->SetUseEtaWeights(WEIGHTS[2]);
+ taskQC->SetnBinsMult(10000);
+ taskQC->SetMinMult(0.);
+ taskQC->SetMaxMult(10000.);
mgr->AddTask(taskQC);
}
if (FQD){
AliAnalysisTaskFittingQDistribution *taskFQD = new AliAnalysisTaskFittingQDistribution("TaskFittingQDistribution",kFALSE);
taskFQD->SetUsePhiWeights(WEIGHTS[0]);
+ taskFQD->SetqMin(0.);
+ taskFQD->SetqMax(1000.);
+ taskFQD->SetqNbins(10000);
mgr->AddTask(taskFQD);
}
if (MCEP){
AliAnalysisTaskMCEventPlane *taskMCEP = new AliAnalysisTaskMCEventPlane("TaskMCEventPlane");
mgr->AddTask(taskMCEP);
}
-
+ if (MH){
+ AliAnalysisTaskMixedHarmonics *taskMH = new AliAnalysisTaskMixedHarmonics("TaskMixedHarmonics",useWeights);
+ taskMH->SetHarmonic(1); // n in cos[n(phi1+phi2-2phi3)] and cos[n(psi1+psi2-2phi3)]
+ taskMH->SetNoOfMultipicityBins(10);
+ taskMH->SetMultipicityBinWidth(2);
+ taskMH->SetMinMultiplicity(3);
+ taskMH->SetCorrectForDetectorEffects(kTRUE);
+ taskMH->SetEvaluateDifferential3pCorrelator(kFALSE); // evaluate <<cos[n(psi1+psi2-2phi3)]>> (Remark: two nested loops)
+ taskMH->SetOppositeChargesPOI(kFALSE); // POIs psi1 and psi2 in cos[n(psi1+psi2-2phi3)] will have opposite charges
+ mgr->AddTask(taskMH);
+ }
+ if (NL){
+ AliAnalysisTaskNestedLoops *taskNL = new AliAnalysisTaskNestedLoops("TaskNestedLoops",useWeights);
+ taskNL->SetHarmonic(1); // n in cos[n(phi1+phi2-2phi3)] and cos[n(psi1+psi2-2phi3)]
+ taskNL->SetEvaluateNestedLoopsForRAD(kTRUE); // RAD = Relative Angle Distribution
+ taskNL->SetEvaluateNestedLoopsForMH(kTRUE); // evalaute <<cos[n(phi1+phi2-2phi3)]>> (Remark: three nested loops)
+ taskNL->SetEvaluateDifferential3pCorrelator(kFALSE); // evaluate <<cos[n(psi1+psi2-2phi3)]>> (Remark: three nested loops)
+ taskNL->SetOppositeChargesPOI(kFALSE); // POIs psi1 and psi2 in cos[n(psi1+psi2-2phi3)] will have opposite charges
+ mgr->AddTask(taskNL);
+ }
+
// Create the output container for the data produced by the task
// Connect to the input and output containers
//===========================================================================
AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
- AliAnalysisDataContainer *coutputFE = mgr->CreateContainer("cobjFlowEventSimple", AliFlowEventSimple::Class(),AliAnalysisManager::kExchangeContainer);
+
+ if (rptype == "FMD") {
+ AliAnalysisDataContainer *coutputFMD =
+ mgr->CreateContainer("BackgroundCorrected", TList::Class(), AliAnalysisManager::kExchangeContainer);
+ //input and output taskFMD
+ mgr->ConnectInput(taskfmd, 0, cinput1);
+ mgr->ConnectOutput(taskfmd, 1, coutputFMD);
+ //input into taskFE
+ mgr->ConnectInput(taskFE,1,coutputFMD);
+ }
+
+ AliAnalysisDataContainer *coutputFE =
+ mgr->CreateContainer("cobjFlowEventSimple", AliFlowEventSimple::Class(),AliAnalysisManager::kExchangeContainer);
mgr->ConnectInput(taskFE,0,cinput1);
mgr->ConnectOutput(taskFE,1,coutputFE);
AliAnalysisDataContainer *coutputLYZ1SUM = mgr->CreateContainer("cobjLYZ1SUM", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1SUM);
mgr->ConnectInput(taskLYZ1SUM,0,coutputFE);
- mgr->ConnectOutput(taskLYZ1SUM,0,coutputLYZ1SUM);
+ mgr->ConnectOutput(taskLYZ1SUM,1,coutputLYZ1SUM);
}
if(LYZ1PROD) {
TString outputLYZ1PROD = AliAnalysisManager::GetCommonFileName();
AliAnalysisDataContainer *coutputLYZ1PROD = mgr->CreateContainer("cobjLYZ1PROD", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1PROD);
mgr->ConnectInput(taskLYZ1PROD,0,coutputFE);
- mgr->ConnectOutput(taskLYZ1PROD,0,coutputLYZ1PROD);
+ mgr->ConnectOutput(taskLYZ1PROD,1,coutputLYZ1PROD);
}
if(LYZ2SUM) {
AliAnalysisDataContainer *cinputLYZ2SUM = mgr->CreateContainer("cobjLYZ2SUMin",TList::Class(),AliAnalysisManager::kInputContainer);
AliAnalysisDataContainer *coutputLYZ2SUM = mgr->CreateContainer("cobjLYZ2SUM", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2SUM);
mgr->ConnectInput(taskLYZ2SUM,0,coutputFE);
mgr->ConnectInput(taskLYZ2SUM,1,cinputLYZ2SUM);
- mgr->ConnectOutput(taskLYZ2SUM,0,coutputLYZ2SUM);
+ mgr->ConnectOutput(taskLYZ2SUM,1,coutputLYZ2SUM);
cinputLYZ2SUM->SetData(fInputListLYZ2SUM);
}
if(LYZ2PROD) {
AliAnalysisDataContainer *coutputLYZ2PROD = mgr->CreateContainer("cobjLYZ2PROD", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2PROD);
mgr->ConnectInput(taskLYZ2PROD,0,coutputFE);
mgr->ConnectInput(taskLYZ2PROD,1,cinputLYZ2PROD);
- mgr->ConnectOutput(taskLYZ2PROD,0,coutputLYZ2PROD);
+ mgr->ConnectOutput(taskLYZ2PROD,1,coutputLYZ2PROD);
cinputLYZ2PROD->SetData(fInputListLYZ2PROD);
}
if(LYZEP) {
AliAnalysisDataContainer *coutputLYZEP = mgr->CreateContainer("cobjLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZEP);
mgr->ConnectInput(taskLYZEP,0,coutputFE);
mgr->ConnectInput(taskLYZEP,1,cinputLYZEP);
- mgr->ConnectOutput(taskLYZEP,0,coutputLYZEP);
+ mgr->ConnectOutput(taskLYZEP,1,coutputLYZEP);
cinputLYZEP->SetData(fInputListLYZEP);
}
if(GFC) {
AliAnalysisDataContainer *coutputGFC = mgr->CreateContainer("cobjGFC", TList::Class(),AliAnalysisManager::kOutputContainer,outputGFC);
mgr->ConnectInput(taskGFC,0,coutputFE);
- mgr->ConnectOutput(taskGFC,0,coutputGFC);
+ mgr->ConnectOutput(taskGFC,1,coutputGFC);
if (useWeights) {
mgr->ConnectInput(taskGFC,1,cinputWeights);
cinputWeights->SetData(weightsList);
AliAnalysisDataContainer *coutputQC = mgr->CreateContainer("cobjQC", TList::Class(),AliAnalysisManager::kOutputContainer,outputQC);
mgr->ConnectInput(taskQC,0,coutputFE);
- mgr->ConnectOutput(taskQC,0,coutputQC);
+ mgr->ConnectOutput(taskQC,1,coutputQC);
if (useWeights) {
mgr->ConnectInput(taskQC,1,cinputWeights);
cinputWeights->SetData(weightsList);
- }
+ }
}
if(FQD) {
TString outputFQD = AliAnalysisManager::GetCommonFileName();
AliAnalysisDataContainer *coutputFQD = mgr->CreateContainer("cobjFQD", TList::Class(),AliAnalysisManager::kOutputContainer,outputFQD);
mgr->ConnectInput(taskFQD,0,coutputFE);
- mgr->ConnectOutput(taskFQD,0,coutputFQD);
+ mgr->ConnectOutput(taskFQD,1,coutputFQD);
if(useWeights) {
mgr->ConnectInput(taskFQD,1,cinputWeights);
cinputWeights->SetData(weightsList);
AliAnalysisDataContainer *coutputMCEP = mgr->CreateContainer("cobjMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputMCEP);
mgr->ConnectInput(taskMCEP,0,coutputFE);
- mgr->ConnectOutput(taskMCEP,0,coutputMCEP);
+ mgr->ConnectOutput(taskMCEP,1,coutputMCEP);
+ }
+ if(MH) {
+ TString outputMH = AliAnalysisManager::GetCommonFileName();
+ outputMH += ":outputMHanalysis";
+ outputMH += type;
+
+ AliAnalysisDataContainer *coutputMH = mgr->CreateContainer("cobjMH", TList::Class(),AliAnalysisManager::kOutputContainer,outputMH);
+ mgr->ConnectInput(taskMH,0,coutputFE);
+ mgr->ConnectOutput(taskMH,1,coutputMH);
+ //if (useWeights) {
+ // mgr->ConnectInput(taskMH,1,cinputWeights);
+ // cinputWeights->SetData(weightsList);
+ //}
+ }
+ if(NL) {
+ TString outputNL = AliAnalysisManager::GetCommonFileName();
+ outputNL += ":outputNLanalysis";
+ outputNL += type;
+
+ AliAnalysisDataContainer *coutputNL = mgr->CreateContainer("cobjNL", TList::Class(),AliAnalysisManager::kOutputContainer,outputNL);
+ mgr->ConnectInput(taskNL,0,coutputFE);
+ mgr->ConnectOutput(taskNL,1,coutputNL);
+ //if (useWeights) {
+ // mgr->ConnectInput(taskNL,1,cinputWeights);
+ // cinputWeights->SetData(weightsList);
+ //}
}
-
// Return analysis task
//===========================================================================
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff