X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=PWG2%2FFLOW%2Fmacros%2FAddTaskFlow.C;h=444df54a0e97d1c3b51c7dac07850c59d1ecb914;hb=644f1368e3a1e9c25cdd67a3b9e850bff7dba34e;hp=9394188a441f9f6ae6f3a80b6e1689c44e822cf2;hpb=a554b20301bc1397f6bfe84f087aa092d839521b;p=u%2Fmrichter%2FAliRoot.git diff --git a/PWG2/FLOW/macros/AddTaskFlow.C b/PWG2/FLOW/macros/AddTaskFlow.C index 9394188a441..444df54a0e9 100644 --- a/PWG2/FLOW/macros/AddTaskFlow.C +++ b/PWG2/FLOW/macros/AddTaskFlow.C @@ -7,195 +7,204 @@ // ///////////////////////////////////////////////////////////////////////////////////////////// -// Define the range for eta subevents (for SP method) -Double_t minA = -0.9; -Double_t maxA = -0.1; -Double_t minB = 0.1; -Double_t maxB = 0.9; - -// use physics selection class -Bool_t UsePhysicsSelection = kTRUE; - -// SETTING THE CUTS - -//----------Event selection---------- -Bool_t UseMultCutforESD = kTRUE; -//Bool_t UseMultCutforESD = kFALSE; -const Int_t multminESD = 1; //used for CORRFW cuts -const Int_t multmaxESD = 1000000; //used for CORRFW cuts - -Bool_t requireVtxCuts = kTRUE; -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 = 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---------- -//KINEMATICS (on generated and reconstructed tracks) -Bool_t UseKineforRP = kTRUE; -const Double_t ptminRP = 0.0; -const Double_t ptmaxRP = 10.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; -const Int_t PdgRP = 211; - -//TRACK QUALITY (on reconstructed tracks only) -//see /CORRFW/AliCFTrackQualityCuts class -Bool_t UseTrackQualityforRP = kTRUE; -const Int_t minClustersTpcRP = 80; //default = -1; -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; -const Int_t minClustersTrdRP = -1; -const Int_t minTrackletTrdRP = -1; -const Int_t minTrackletTrdPidRP = -1; -const Double_t maxChi2PerClusterTrdRP = 1.e+09; -const ULong_t statusRP = AliESDtrack::kTPCrefit; //AliESDtrack::kTPCrefit & AliESDtrack::kITSrefit - -//PRIMARY (on reconstructed tracks only) -//see /CORRFW/AliCFTrackIsPrimaryCuts class -Bool_t UsePrimariesforRP = kTRUE; -const Bool_t spdVertexRP = kFALSE; -const Bool_t tpcVertexRP = kFALSE; -const Float_t minDcaToVertexXyRP = 0.; -const Float_t minDcaToVertexZRP = 0.; -const Float_t maxDcaToVertexXyRP = 2.4; //default = 1.e+10; //2.4; -const Float_t maxDcaToVertexZRP = 3.2; //default = 1.e+10; //3.2; -const Bool_t dcaToVertex2dRP = kFALSE; //default = kFALSE; -const Bool_t absDcaToVertexRP = kTRUE; //default = kTRUE; -const Double_t minNSigmaToVertexRP = 0.; -const Double_t maxNSigmaToVertexRP = 1.e+10; //3.; //1.e+10 -const Double_t maxSigmaDcaXySP = 1.e+10; -const Double_t maxSigmaDcaZSP = 1.e+10; -const Bool_t requireSigmaToVertexSP = kFALSE; -const Bool_t acceptKinkDaughtersSP = kFALSE; //default = kTRUE; - -//ACCEPTANCE (on generated tracks only : AliMCParticle) -//see /CORRFW/AliCFAcceptanceCuts class -Bool_t UseAcceptanceforRP = kFALSE; -const Int_t minTrackrefsItsRP = 0;//3; -const Int_t minTrackrefsTpcRP = 0;//2; -const Int_t minTrackrefsTrdRP = 0; -const Int_t minTrackrefsTofRP = 0; -const Int_t minTrackrefsMuonRP = 0; -//default for all is 0 - -//----------For POI selection---------- -//KINEMATICS (on generated and reconstructed tracks) -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 Int_t chargePOI = 1; //not used -const Bool_t isChargedPOI = kTRUE; - -//PID (on generated and reconstructed tracks) -Bool_t UsePIDforPOI = kFALSE; -const Int_t PdgPOI = 321; - -//TRACK QUALITY (on reconstructed tracks only) -//see /CORRFW/AliCFTrackQualityCuts class -Bool_t UseTrackQualityforPOI = kTRUE; -const Int_t minClustersTpcPOI = 80; -const Double_t maxChi2PerClusterTpcPOI = 4.0; -const UShort_t minDedxClusterTpcPOI = 0; -const Int_t minClustersItsPOI = 2; -const Double_t maxChi2PerClusterItsPOI = 1.e+09; -const Int_t minClustersTrdPOI = -1; -const Int_t minTrackletTrdPOI = -1; -const Int_t minTrackletTrdPidPOI = -1; -const Double_t maxChi2PerClusterTrdPOI = 1.e+09; -const ULong_t statusPOI = AliESDtrack::kTPCrefit; - -//PRIMARY (on reconstructed tracks only) -//see /CORRFW/AliCFTrackIsPrimaryCuts class -Bool_t UsePrimariesforPOI = kTRUE; -const Bool_t spdVertexPOI = kFALSE; -const Bool_t tpcVertexPOI = kFALSE; -const Float_t minDcaToVertexXyPOI = 0.; -const Float_t minDcaToVertexZPOI = 0.; -const Float_t maxDcaToVertexXyPOI = 2.4; -const Float_t maxDcaToVertexZPOI = 3.2; -const Bool_t dcaToVertex2dPOI = kFALSE; -const Bool_t absDcaToVertexPOI = kTRUE; -const Double_t minNSigmaToVertexPOI = 0.; -const Double_t maxNSigmaToVertexPOI = 1.e+10; -const Double_t maxSigmaDcaXyPOI = 1.e+10; -const Double_t maxSigmaDcaZPOI = 1.e+10; -const Bool_t requireSigmaToVertexPOI = kFALSE; -const Bool_t acceptKinkDaughtersPOI = kFALSE; - -//ACCEPTANCE (on generated tracks only : AliMCParticle) -//see /CORRFW/AliCFAcceptanceCuts class -Bool_t UseAcceptanceforPOI = kFALSE; -const Int_t minTrackrefsItsPOI = 3; -const Int_t minTrackrefsTpcPOI = 2; -const Int_t minTrackrefsTrdPOI = 0; -const Int_t minTrackrefsTofPOI = 0; -const Int_t minTrackrefsMuonPOI = 0; - - -//----------For Adding Flow to the Event---------- -const Bool_t AddToEvent = kFALSE; -Double_t ellipticFlow = 0.05; - - -AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, Bool_t* WEIGHTS) +void AddTaskFlow(Float_t centrMin=-1, + Float_t centrMax=-1, + TString fileNameBase="AnalysisResults" ) { - //boleans for the methods - Bool_t SP = METHODS[0]; - Bool_t LYZ1SUM = METHODS[1]; - Bool_t LYZ1PROD = METHODS[2]; - Bool_t LYZ2SUM = METHODS[3]; - Bool_t LYZ2PROD = METHODS[4]; - Bool_t LYZEP = METHODS[5]; - Bool_t GFC = METHODS[6]; - Bool_t QC = METHODS[7]; - Bool_t FQD = METHODS[8]; - Bool_t MCEP = METHODS[9]; - Bool_t MH = METHODS[10]; - Bool_t NL = METHODS[11]; - //for using weights + // Define the range for eta subevents (for SP method) + Double_t minA = -0.9; + Double_t maxA = -0.5; + Double_t minB = 0.5; + Double_t maxB = 0.9; + /* + //PMD As RP + Double_t minB = 2.3; + Double_t maxB = 3.1; + Double_t minA = 3.1; + Double_t maxA = 3.9; + */ + + // AFTERBURNER + Bool_t useAfterBurner=kFALSE; + Double_t v1=0.0; + Double_t v2=0.0; + Double_t v3=0.0; + Double_t v4=0.0; + Int_t numberOfTrackClones=0; //non-flow + + // Define a range of the detector to exclude + Bool_t ExcludeRegion = kFALSE; + Double_t excludeEtaMin = -0.; + Double_t excludeEtaMax = 0.; + Double_t excludePhiMin = 0.; + Double_t excludePhiMax = 0.; + + // use physics selection class + Bool_t UsePhysicsSelection = kTRUE; + + // charge of poi + const Int_t chargePOI = 1; + + // QA + Bool_t runQAtask=kFALSE; + Bool_t FillQAntuple=kFALSE; + Bool_t DoQAcorrelations=kFALSE; + + // RUN SETTINGS + // Flow analysis method can be:(set to kTRUE or kFALSE) + Bool_t MCEP = kTRUE; // correlation with Monte Carlo reaction plane + Bool_t SP = kTRUE; // scalar product method (similar to eventplane method) + Bool_t GFC = kTRUE; // cumulants based on generating function + Bool_t QC = kTRUE; // cumulants using Q vectors + Bool_t FQD = kTRUE; // fit of the distribution of the Q vector (only integrated v) + Bool_t LYZ1SUM = kTRUE; // Lee Yang Zeroes using sum generating function (integrated v) + Bool_t LYZ1PROD = kFALSE; // Lee Yang Zeroes using product generating function (integrated v) + Bool_t LYZ2SUM = kFALSE; // Lee Yang Zeroes using sum generating function (second pass differential v) + Bool_t LYZ2PROD = kFALSE; // Lee Yang Zeroes using product generating function (second pass differential v) + Bool_t LYZEP = kFALSE; // Lee Yang Zeroes Event plane using sum generating function (gives eventplane + weight) + Bool_t MH = kTRUE; // azimuthal correlators in mixed harmonics + Bool_t NL = kFALSE; // nested loops (for instance distribution of phi1-phi2 for all distinct pairs) + + Bool_t METHODS[] = {SP,LYZ1SUM,LYZ1PROD,LYZ2SUM,LYZ2PROD,LYZEP,GFC,QC,FQD,MCEP,MH,NL}; + + // Boolean to use/not use weights for the Q vector + Bool_t WEIGHTS[] = {kFALSE,kFALSE,kFALSE}; //Phi, v'(pt), v'(eta) + + // SETTING THE CUTS + + //---------Data selection---------- + //kMC, kGlobal, kTPCstandalone, kSPDtracklet, kPMD + AliFlowTrackCuts::trackParameterType rptype = AliFlowTrackCuts::kGlobal; + AliFlowTrackCuts::trackParameterType poitype = AliFlowTrackCuts::kGlobal; + + //---------Parameter mixing-------- + //kPure - no mixing, kTrackWithMCkine, kTrackWithMCPID, kTrackWithMCpt + AliFlowTrackCuts::trackParameterMix rpmix = AliFlowTrackCuts::kPure; + AliFlowTrackCuts::trackParameterMix poimix = AliFlowTrackCuts::kPure; + + + const char* rptypestr = AliFlowTrackCuts::GetParamTypeName(rptype); + const char* poitypestr = AliFlowTrackCuts::GetParamTypeName(poitype); + + + TString centralityName(""); + if((centrMin > 0)||(centrMax > 0)) { + centralityName+=Form("%.0f",centrMin); + centralityName+="-"; + centralityName+=Form("%.0f",centrMax); + } + + TString fileName(fileNameBase); + fileName.Append(".root"); + //=========================================================================== + printf("CREATE CUTS\n"); + cout << "Used for RP: "<< rptypestr << endl; + cout << "Used for POI: "<< poitypestr << endl; + // EVENTS CUTS: + AliFlowEventCuts* cutsEvent = new AliFlowEventCuts("event cuts"); + if((centrMin > 0)||(centrMax > 0)) { + cutsEvent->SetCentralityPercentileRange(centrMin,centrMax); + cutsEvent->SetCentralityPercentileMethod(AliFlowEventCuts::kV0); + cutsEvent->SetRefMultMethod(AliFlowEventCuts::kV0); + //cutsEvent->SetCentralityPercentileMethod(AliFlowEventCuts::kSPD1tracklets); + cutsEvent->SetNContributorsRange(2); + cutsEvent->SetPrimaryVertexZrange(-10.,10.); + cutsEvent->SetCutSPDvertexerAnomaly(); //"Francesco's cut" + cutsEvent->SetCutZDCtiming(); + } + + // RP TRACK CUTS: + AliFlowTrackCuts* cutsRP = new AliFlowTrackCuts("rp cuts"); + cutsRP->SetParamType(rptype); + cutsRP->SetParamMix(rpmix); + cutsRP->SetPtRange(0.2,5.); + cutsRP->SetEtaRange(-0.8,0.8); + //cutsRP->SetRequireCharge(kTRUE); + //cutsRP->SetCharge(chargeRP); + //cutsRP->SetPID(PdgRP); + if(rptype != AliFlowTrackCuts::kMC) { + cutsRP->SetMinNClustersTPC(70); + cutsRP->SetMinChi2PerClusterTPC(0.1); + cutsRP->SetMaxChi2PerClusterTPC(4.0); + cutsRP->SetMinNClustersITS(2); + cutsRP->SetRequireITSRefit(kTRUE); + cutsRP->SetRequireTPCRefit(kTRUE); + //cutsRP->SetMaxChi2PerClusterITS(1.e+09); + cutsRP->SetMaxDCAToVertexXY(0.3); + cutsRP->SetMaxDCAToVertexZ(0.3); + //cutsRP->SetDCAToVertex2D(kTRUE); + //cutsRP->SetMaxNsigmaToVertex(1.e+10); + //cutsRP->SetRequireSigmaToVertex(kFALSE); + cutsRP->SetAcceptKinkDaughters(kFALSE); + } + if(rptype == AliFlowTrackCuts::kPMD) { + cutsRP->SetEtaRange(2.3,3.9); + cutsRP->SetPmdDetPlane(0); + cutsRP->SetPmdAdc(270); + cutsRP->SetPmdNcell(1); + } + + + // POI TRACK CUTS: + AliFlowTrackCuts* cutsPOI = new AliFlowTrackCuts("poi cuts"); + cutsPOI->SetParamType(poitype); + cutsPOI->SetParamMix(poimix); + cutsPOI->SetPtRange(0.0,10.); + cutsPOI->SetEtaRange(-1.2,1.2); + if(chargePOI != 0) + cutsPOI->SetCharge(chargePOI); + //cutsPOI->SetRequireCharge(kTRUE); + //cutsPOI->SetPID(PdgRP); + if(rptype != AliFlowTrackCuts::kMC) { + cutsPOI->SetMinNClustersTPC(80); + cutsPOI->SetMinChi2PerClusterTPC(0.1); + cutsPOI->SetMaxChi2PerClusterTPC(4.0); + cutsPOI->SetRequireITSRefit(kTRUE); + cutsPOI->SetRequireTPCRefit(kTRUE); + cutsPOI->SetMinNClustersITS(2); + //cutsPOI->SetMaxChi2PerClusterITS(1.e+09); + cutsPOI->SetMaxDCAToVertexXY(0.3); + cutsPOI->SetMaxDCAToVertexZ(0.3); + //cutsPOI->SetDCAToVertex2D(kTRUE); + //cutsPOI->SetMaxNsigmaToVertex(1.e+10); + //cutsPOI->SetRequireSigmaToVertex(kFALSE); + cutsPOI->SetAcceptKinkDaughters(kFALSE); + //cutsPOI->SetPID(AliPID::kProton, AliFlowTrackCuts::kTOFpid); + //cutsPOI->SetPID(AliPID::kPion, AliFlowTrackCuts::kTPCpid); + //cutsPOI->SetPID(AliPID::kProton, AliFlowTrackCuts::kTPCTOFpid); + //cutsPOI->SetTPCTOFpidCrossOverPt(0.4); + //francesco's TPC Bethe Bloch for data: + //cutsPOI->GetESDpid().GetTPCResponse().SetBetheBlochParameters(4.36414e-02,1.75977e+01,1.14385e-08,2.27907e+00,3.36699e+00); + //cutsPOI->GetESDpid().GetTPCResponse().SetMip(49); + } + if(poitype == AliFlowTrackCuts::kPMD) { + cutsPOI->SetEtaRange(2.3,3.9); + cutsPOI->SetPmdDetPlane(0); + cutsPOI->SetPmdAdc(270); + cutsPOI->SetPmdNcell(1); + } + + Bool_t useWeights = WEIGHTS[0] || WEIGHTS[1] || WEIGHTS[2]; if (useWeights) cout<<"Weights are used"<GetInputEventHandler()) { ::Error("AddTaskFlowEvent", "This task requires an input event handler"); return NULL; } - + // Open external input files //=========================================================================== //weights: @@ -214,7 +223,7 @@ AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, break; } } - + //LYZ2 if (LYZ2SUM || LYZ2PROD) { //read the outputfile of the first run @@ -227,14 +236,12 @@ AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, cout<<"WARNING: You do not have an output file:"<FindObjectAny(inputFileNameLYZ2SUM.Data()); if(!fInputFileLYZ2SUM || fInputFileLYZ2SUM->IsZombie()) { @@ -251,7 +258,7 @@ AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, if (LYZ2PROD){ // read the output directory from LYZ1PROD TString inputFileNameLYZ2PROD = "outputLYZ1PRODanalysis" ; - inputFileNameLYZ2PROD += type; + inputFileNameLYZ2PROD += rptypestr; cout<<"The input directory is "<FindObjectAny(inputFileNameLYZ2PROD.Data()); if(!fInputFileLYZ2PROD || fInputFileLYZ2PROD->IsZombie()) { @@ -266,7 +273,6 @@ AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, } } - if (LYZEP) { //read the outputfile of the second run TString outputFileName = "AnalysisResults2.root"; @@ -281,10 +287,10 @@ AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, } else { outputFile = TFile::Open(pwd.Data(),"READ"); } - + // read the output file from LYZ2SUM TString inputFileNameLYZEP = "outputLYZ2SUManalysis" ; - inputFileNameLYZEP += type; + inputFileNameLYZEP += rptypestr; cout<<"The input file is "<FindObjectAny(inputFileNameLYZEP.Data()); if(!fInputFileLYZEP || fInputFileLYZEP->IsZombie()) { @@ -298,366 +304,61 @@ AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, cout<<"LYZEP input file/list read..."<SetEllipticFlowValue(ellipticFlow); } //TEST - else {taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kTRUE); } - taskFE->SetAnalysisType(type); - if (UseMultCut) { - taskFE->SetMinMult(multmin); - taskFE->SetMaxMult(multmax); - } - taskFE->SetSubeventEtaRange(minA, maxA, minB, maxB); - if (UsePhysicsSelection) { - taskFE->SelectCollisionCandidates(); - cout<<"Using Physics Selection"<AddTask(taskFE); - } - else { - if(AddToEvent) { - taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kFALSE,1); - taskFE->SetEllipticFlowValue(ellipticFlow); } //TEST - else {taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kFALSE); } - taskFE->SetAnalysisType(type); - if (UseMultCut) { - taskFE->SetMinMult(multmin); - taskFE->SetMaxMult(multmax); - } - taskFE->SetSubeventEtaRange(minA, maxA, minB, maxB); - if (UsePhysicsSelection) { - taskFE->SelectCollisionCandidates(); - cout<<"Using Physics Selection"<AddTask(taskFE); - } - - // Create cuts using the correction framework (CORRFW) - //=========================================================================== - if (QA){ - //Set TList for the QA histograms - TList* qaRP = new TList(); - TList* qaPOI = new TList(); - } - - //----------Event cuts---------- - AliCFEventGenCuts* mcEventCuts = new AliCFEventGenCuts("mcEventCuts","MC-level event cuts"); - mcEventCuts->SetNTracksCut(multminESD,multmaxESD); - mcEventCuts->SetRequireVtxCuts(requireVtxCuts); - mcEventCuts->SetVertexXCut(vertexXmin, vertexXmax); - mcEventCuts->SetVertexYCut(vertexYmin, vertexYmax); - mcEventCuts->SetVertexZCut(vertexZmin, vertexZmax); - if (QA) { - mcEventCuts->SetQAOn(qaRP); - } - AliCFEventRecCuts* recEventCuts = new AliCFEventRecCuts("recEventCuts","rec-level event cuts"); - recEventCuts->SetNTracksCut(multminESD,multmaxESD); - recEventCuts->SetRequireVtxCuts(requireVtxCuts); - recEventCuts->SetVertexXCut(vertexXmin, vertexXmax); - recEventCuts->SetVertexYCut(vertexYmin, vertexYmax); - recEventCuts->SetVertexZCut(vertexZmin, vertexZmax); - recEventCuts->SetVertexNContributors(vertexNContributorsmin,vertexNContributorsmax); - if (QA) { - recEventCuts->SetQAOn(qaRP); - } - //----------Cuts for RP---------- - //KINEMATICS (MC and reconstructed) - AliCFTrackKineCuts* mcKineCutsRP = new AliCFTrackKineCuts("mcKineCutsRP","MC-level kinematic cuts"); - mcKineCutsRP->SetPtRange(ptminRP,ptmaxRP); - mcKineCutsRP->SetEtaRange(etaminRP,etamaxRP); - //mcKineCutsRP->SetChargeMC(chargeRP); - mcKineCutsRP->SetRequireIsCharged(isChargedRP); - if (QA) { - mcKineCutsRP->SetQAOn(qaRP); - } - - AliCFTrackKineCuts *recKineCutsRP = new AliCFTrackKineCuts("recKineCutsRP","rec-level kine cuts"); - recKineCutsRP->SetPtRange(ptminRP,ptmaxRP); - recKineCutsRP->SetEtaRange(etaminRP,etamaxRP); - //recKineCutsRP->SetChargeRec(chargeRP); - recKineCutsRP->SetRequireIsCharged(isChargedRP); - if (QA) { - recKineCutsRP->SetQAOn(qaRP); - } - - //PID (MC and reconstructed) - AliCFParticleGenCuts* mcGenCutsRP = new AliCFParticleGenCuts("mcGenCutsRP","MC particle generation cuts for RP"); - mcGenCutsRP->SetRequireIsPrimary(); - if (UsePIDforRP) {mcGenCutsRP->SetRequirePdgCode(PdgRP);} - if (QA) { - mcGenCutsRP->SetQAOn(qaRP); - } - - int n_species = AliPID::kSPECIES ; - Double_t* prior = new Double_t[n_species]; - - prior[0] = 0.0244519 ; - prior[1] = 0.0143988 ; - prior[2] = 0.805747 ; - prior[3] = 0.0928785 ; - prior[4] = 0.0625243 ; - - AliCFTrackCutPid* cutPidRP = NULL; - if(UsePIDforRP) { - cutPidRP = new AliCFTrackCutPid("cutPidRP","ESD_PID for RP") ; - cutPidRP->SetPriors(prior); - cutPidRP->SetProbabilityCut(0.0); - cutPidRP->SetDetectors("TPC TOF"); - switch(TMath::Abs(PDG1)) { - case 11 : cutPidRP->SetParticleType(AliPID::kElectron, kTRUE); break; - case 13 : cutPidRP->SetParticleType(AliPID::kMuon , kTRUE); break; - case 211 : cutPidRP->SetParticleType(AliPID::kPion , kTRUE); break; - case 321 : cutPidRP->SetParticleType(AliPID::kKaon , kTRUE); break; - case 2212 : cutPidRP->SetParticleType(AliPID::kProton , kTRUE); break; - default : printf("UNDEFINED PID\n"); break; - } - if (QA) { - cutPidRP->SetQAOn(qaRP); + // Create the FMD task and add it to the manager + //=========================================================================== + if (rptypestr == "FMD") { + AliFMDAnalysisTaskSE *taskfmd = NULL; + if (rptypestr == "FMD") { + taskfmd = new AliFMDAnalysisTaskSE("TaskFMD"); + mgr->AddTask(taskfmd); + + AliFMDAnaParameters* pars = AliFMDAnaParameters::Instance(); + pars->Init(); + pars->SetProcessPrimary(kTRUE); //for MC only + pars->SetProcessHits(kFALSE); + + //pars->SetRealData(kTRUE); //for real data + //pars->SetProcessPrimary(kFALSE); //for real data } } - //TRACK QUALITY - AliCFTrackQualityCuts *recQualityCutsRP = new AliCFTrackQualityCuts("recQualityCutsRP","rec-level quality cuts"); - recQualityCutsRP->SetMinNClusterTPC(minClustersTpcRP); - //recQualityCutsRP->SetMinFoundClusterTPC(minFoundClustersTpcRP); //only for internal TPC QA - recQualityCutsRP->SetMaxChi2PerClusterTPC(maxChi2PerClusterTpcRP); - recQualityCutsRP->SetMinNdEdxClusterTPC(minDedxClusterTpcRP); //to reject secondaries - - recQualityCutsRP->SetMinNClusterITS(minClustersItsRP); - recQualityCutsRP->SetMaxChi2PerClusterITS(maxChi2PerClusterItsRP); - - recQualityCutsRP->SetMinNClusterTRD(minClustersTrdRP); - recQualityCutsRP->SetMinNTrackletTRD(minTrackletTrdRP); - recQualityCutsRP->SetMinNTrackletTRDpid(minTrackletTrdPidRP); - recQualityCutsRP->SetMaxChi2PerTrackletTRD(maxChi2PerClusterTrdRP); - recQualityCutsRP->SetStatus(statusRP); - if (QA) { - recQualityCutsRP->SetQAOn(qaRP); - } - - /* - //How to set this? - void SetMaxCovDiagonalElements(Float_t c1=1.e+09, Float_t c2=1.e+09, Float_t c3=1.e+09, Float_t c4=1.e+09, Float_t c5=1.e+09) - {fCovariance11Max=c1;fCovariance22Max=c2;fCovariance33Max=c3;fCovariance44Max=c4;fCovariance55Max=c5;} - */ - - //PRIMARIES - AliCFTrackIsPrimaryCuts *recIsPrimaryCutsRP = new AliCFTrackIsPrimaryCuts("recIsPrimaryCutsRP","rec-level isPrimary cuts"); - recIsPrimaryCutsRP->UseSPDvertex(spdVertexRP); - recIsPrimaryCutsRP->UseTPCvertex(tpcVertexRP); - recIsPrimaryCutsRP->SetMinDCAToVertexXY(minDcaToVertexXyRP); - recIsPrimaryCutsRP->SetMinDCAToVertexZ(minDcaToVertexZRP); - recIsPrimaryCutsRP->SetMaxDCAToVertexXY(maxDcaToVertexXyRP); - recIsPrimaryCutsRP->SetMaxDCAToVertexZ(maxDcaToVertexZRP); - recIsPrimaryCutsRP->SetDCAToVertex2D(dcaToVertex2dRP); - recIsPrimaryCutsRP->SetAbsDCAToVertex(absDcaToVertexRP); - recIsPrimaryCutsRP->SetMinNSigmaToVertex(minNSigmaToVertexRP); - recIsPrimaryCutsRP->SetMaxNSigmaToVertex(maxNSigmaToVertexRP); - recIsPrimaryCutsRP->SetMaxSigmaDCAxy(maxSigmaDcaXySP); - recIsPrimaryCutsRP->SetMaxSigmaDCAz(maxSigmaDcaZSP); - recIsPrimaryCutsRP->SetRequireSigmaToVertex(requireSigmaToVertexSP); - recIsPrimaryCutsRP->SetAcceptKinkDaughters(acceptKinkDaughtersSP); - if (QA) { - recIsPrimaryCutsRP->SetQAOn(qaRP); - } - - //ACCEPTANCE - AliCFAcceptanceCuts *mcAccCutsRP = new AliCFAcceptanceCuts("mcAccCutsRP","MC acceptance cuts"); - mcAccCutsRP->SetMinNHitITS(minTrackrefsItsRP); - mcAccCutsRP->SetMinNHitTPC(minTrackrefsTpcRP); - mcAccCutsRP->SetMinNHitTRD(minTrackrefsTrdRP); - mcAccCutsRP->SetMinNHitTOF(minTrackrefsTofRP); - mcAccCutsRP->SetMinNHitMUON(minTrackrefsMuonRP); - if (QA) { - mcAccCutsRP->SetQAOn(qaRP); - } + // Create the task, add it to the manager. + //=========================================================================== + AliAnalysisTaskFlowEvent *taskFE = NULL; - - //----------Cuts for POI---------- - //KINEMATICS (MC and reconstructed) - AliCFTrackKineCuts* mcKineCutsPOI = new AliCFTrackKineCuts("mcKineCutsPOI","MC-level kinematic cuts"); - mcKineCutsPOI->SetPtRange(ptminPOI,ptmaxPOI); - mcKineCutsPOI->SetEtaRange(etaminPOI,etamaxPOI); - //mcKineCutsPOI->SetChargeMC(chargePOI); - mcKineCutsPOI->SetRequireIsCharged(isChargedPOI); - if (QA) { - mcKineCutsPOI->SetQAOn(qaPOI); - } - - AliCFTrackKineCuts *recKineCutsPOI = new AliCFTrackKineCuts("recKineCutsPOI","rec-level kine cuts"); - recKineCutsPOI->SetPtRange(ptminPOI,ptmaxPOI); - recKineCutsPOI->SetEtaRange(etaminPOI,etamaxPOI); - //recKineCutsPOI->SetChargeRec(chargePOI); - recKineCutsPOI->SetRequireIsCharged(isChargedPOI); - if (QA) { - recKineCutsPOI->SetQAOn(qaPOI); - } - - //PID (MC and reconstructed) - AliCFParticleGenCuts* mcGenCutsPOI = new AliCFParticleGenCuts("mcGenCutsPOI","MC particle generation cuts for POI"); - mcGenCutsPOI->SetRequireIsPrimary(); - if (UsePIDforPOI) {mcGenCutsPOI->SetRequirePdgCode(PdgPOI);} - if (QA) { - mcGenCutsPOI->SetQAOn(qaPOI); - } - - AliCFTrackCutPid* cutPidPOI = NULL; - if (UsePIDforPOI) { - cutPidPOI = new AliCFTrackCutPid("cutPidPOI","ESD_PID for POI") ; - cutPidPOI->SetPriors(prior); - cutPidPOI->SetProbabilityCut(0.0); - cutPidPOI->SetDetectors("TPC TOF"); - switch(TMath::Abs(PDG2)) { - case 11 : cutPidPOI->SetParticleType(AliPID::kElectron, kTRUE); break; - case 13 : cutPidPOI->SetParticleType(AliPID::kMuon , kTRUE); break; - case 211 : cutPidPOI->SetParticleType(AliPID::kPion , kTRUE); break; - case 321 : cutPidPOI->SetParticleType(AliPID::kKaon , kTRUE); break; - case 2212 : cutPidPOI->SetParticleType(AliPID::kProton , kTRUE); break; - default : printf("UNDEFINED PID\n"); break; - } - if (QA) { - cutPidPOI->SetQAOn(qaPOI); + if(useAfterBurner) + { + taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent","",kFALSE,1); + taskFE->SetFlow(v1,v2,v3,v4); + taskFE->SetNonFlowNumberOfTrackClones(numberOfTrackClones); + taskFE->SetAfterburnerOn(); } + else {taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent","",kFALSE); } + if (ExcludeRegion) { + taskFE->DefineDeadZone(excludeEtaMin, excludeEtaMax, excludePhiMin, excludePhiMax); } - - //TRACK QUALITY - AliCFTrackQualityCuts *recQualityCutsPOI = new AliCFTrackQualityCuts("recQualityCutsPOI","rec-level quality cuts"); - recQualityCutsPOI->SetMinNClusterTPC(minClustersTpcPOI); - //recQualityCutsPOI->SetMinFoundClusterTPC(minFoundClustersTpcPOI); //only for internal TPC QA - recQualityCutsPOI->SetMaxChi2PerClusterTPC(maxChi2PerClusterTpcPOI); - recQualityCutsPOI->SetMinNdEdxClusterTPC(minDedxClusterTpcPOI); //to reject secondaries - - recQualityCutsPOI->SetMinNClusterITS(minClustersItsPOI); - recQualityCutsPOI->SetMaxChi2PerClusterITS(maxChi2PerClusterItsPOI); - - recQualityCutsPOI->SetMinNClusterTRD(minClustersTrdPOI); - recQualityCutsPOI->SetMinNTrackletTRD(minTrackletTrdPOI); - recQualityCutsPOI->SetMinNTrackletTRDpid(minTrackletTrdPidPOI); - recQualityCutsPOI->SetMaxChi2PerTrackletTRD(maxChi2PerClusterTrdPOI); - recQualityCutsPOI->SetStatus(statusPOI); - if (QA) { - recQualityCutsPOI->SetQAOn(qaPOI); - } - - //PRIMARIES - AliCFTrackIsPrimaryCuts *recIsPrimaryCutsPOI = new AliCFTrackIsPrimaryCuts("recIsPrimaryCutsPOI","rec-level isPrimary cuts"); - recIsPrimaryCutsPOI->UseSPDvertex(spdVertexPOI); - recIsPrimaryCutsPOI->UseTPCvertex(tpcVertexPOI); - recIsPrimaryCutsPOI->SetMinDCAToVertexXY(minDcaToVertexXyPOI); - recIsPrimaryCutsPOI->SetMinDCAToVertexZ(minDcaToVertexZPOI); - recIsPrimaryCutsPOI->SetMaxDCAToVertexXY(maxDcaToVertexXyPOI); - recIsPrimaryCutsPOI->SetMaxDCAToVertexZ(maxDcaToVertexZPOI); - recIsPrimaryCutsPOI->SetDCAToVertex2D(dcaToVertex2dPOI); - recIsPrimaryCutsPOI->SetAbsDCAToVertex(absDcaToVertexPOI); - recIsPrimaryCutsPOI->SetMinNSigmaToVertex(minNSigmaToVertexPOI); - recIsPrimaryCutsPOI->SetMaxNSigmaToVertex(maxNSigmaToVertexPOI); - recIsPrimaryCutsPOI->SetMaxSigmaDCAxy(maxSigmaDcaXyPOI); - recIsPrimaryCutsPOI->SetMaxSigmaDCAz(maxSigmaDcaZPOI); - recIsPrimaryCutsPOI->SetRequireSigmaToVertex(requireSigmaToVertexPOI); - recIsPrimaryCutsPOI->SetAcceptKinkDaughters(acceptKinkDaughtersPOI); - if (QA) { - recIsPrimaryCutsPOI->SetQAOn(qaPOI); - } - - //ACCEPTANCE - AliCFAcceptanceCuts *mcAccCutsPOI = new AliCFAcceptanceCuts("mcAccCutsPOI","MC acceptance cuts"); - mcAccCutsPOI->SetMinNHitITS(minTrackrefsItsPOI); - mcAccCutsPOI->SetMinNHitTPC(minTrackrefsTpcPOI); - mcAccCutsPOI->SetMinNHitTRD(minTrackrefsTrdPOI); - mcAccCutsPOI->SetMinNHitTOF(minTrackrefsTofPOI); - mcAccCutsPOI->SetMinNHitMUON(minTrackrefsMuonPOI); - if (QA) { - mcAccCutsPOI->SetQAOn(qaPOI); - } - - - - //----------Create Cut Lists---------- - printf("CREATE EVENT CUTS\n"); - TObjArray* mcEventList = new TObjArray(0); - if (UseMultCutforESD) mcEventList->AddLast(mcEventCuts);//cut on mult and vertex - - TObjArray* recEventList = new TObjArray(0); - if (UseMultCutforESD) recEventList->AddLast(recEventCuts);//cut on mult and vertex - - printf("CREATE MC KINE CUTS\n"); - TObjArray* mcListRP = new TObjArray(0); - if (UseKineforRP) mcListRP->AddLast(mcKineCutsRP); //cut on pt/eta/phi - mcListRP->AddLast(mcGenCutsRP); //cut on primary and if (UsePIDforRP) MC PID - - TObjArray* mcListPOI = new TObjArray(0); - if (UseKineforPOI) mcListPOI->AddLast(mcKineCutsPOI); //cut on pt/eta/phi - mcListPOI->AddLast(mcGenCutsPOI); //cut on primary and if (UsePIDforPOI) MC PID - - printf("CREATE MC ACCEPTANCE CUTS\n"); - TObjArray* accListRP = new TObjArray(0) ; - if (UseAcceptanceforRP) accListRP->AddLast(mcAccCutsRP); //cut on number of track references - - TObjArray* accListPOI = new TObjArray(0) ; - if (UseAcceptanceforPOI) accListPOI->AddLast(mcAccCutsPOI); //cut on number of track references - - printf("CREATE ESD RECONSTRUCTION CUTS\n"); - TObjArray* recListRP = new TObjArray(0) ; - 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 (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 - - TObjArray* fPIDCutListPOI = new TObjArray(0) ; - if (UsePIDforPOI) {fPIDCutListPOI->AddLast(cutPidPOI);} //cut on ESD PID - - - //----------Add Cut Lists to the CF Manager---------- - printf("CREATE INTERFACE AND CUTS\n"); - AliCFManager* cfmgrRP = new AliCFManager(); - cfmgrRP->SetNStepEvent(3); - cfmgrRP->SetEventCutsList(AliCFManager::kEvtGenCuts,mcEventList); - cfmgrRP->SetEventCutsList(AliCFManager::kEvtRecCuts,recEventList); - cfmgrRP->SetNStepParticle(4); - cfmgrRP->SetParticleCutsList(AliCFManager::kPartGenCuts,mcListRP); - cfmgrRP->SetParticleCutsList(AliCFManager::kPartAccCuts,accListRP); - cfmgrRP->SetParticleCutsList(AliCFManager::kPartRecCuts,recListRP); - cfmgrRP->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutListRP); - - AliCFManager* cfmgrPOI = new AliCFManager(); - cfmgrPOI->SetNStepEvent(3); - cfmgrPOI->SetEventCutsList(AliCFManager::kEvtGenCuts,mcEventList); - cfmgrPOI->SetEventCutsList(AliCFManager::kEvtRecCuts,recEventList); - cfmgrPOI->SetNStepParticle(4); - cfmgrPOI->SetParticleCutsList(AliCFManager::kPartGenCuts,mcListPOI); - cfmgrPOI->SetParticleCutsList(AliCFManager::kPartAccCuts,accListPOI); - cfmgrPOI->SetParticleCutsList(AliCFManager::kPartRecCuts,recListPOI); - cfmgrPOI->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutListPOI); - - if (QA) { - taskFE->SetQAList1(qaRP); - taskFE->SetQAList2(qaPOI); + taskFE->SetSubeventEtaRange(minA, maxA, minB, maxB); + if (UsePhysicsSelection) { + //taskFE->SelectCollisionCandidates(AliVEvent::kUserDefined); + taskFE->SelectCollisionCandidates(AliVEvent::kMB); + cout<<"Using Physics Selection"<SetCFManager1(cfmgrRP); - taskFE->SetCFManager2(cfmgrPOI); - + mgr->AddTask(taskFE); + + // Pass cuts for RPs and POIs to the task: + taskFE->SetCutsEvent(cutsEvent); + // Pass cuts for RPs and POIs to the task: + taskFE->SetCutsRP(cutsRP); + taskFE->SetCutsPOI(cutsPOI); // Create the analysis tasks, add them to the manager. //=========================================================================== if (SP){ AliAnalysisTaskScalarProduct *taskSP = new AliAnalysisTaskScalarProduct("TaskScalarProduct",WEIGHTS[0]); - taskSP->SetRelDiffMsub(0.1); + taskSP->SetRelDiffMsub(1.0); + taskSP->SetApplyCorrectionForNUA(kTRUE); mgr->AddTask(taskSP); } if (LYZ1SUM){ @@ -700,11 +401,18 @@ AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, taskQC->SetUsePhiWeights(WEIGHTS[0]); taskQC->SetUsePtWeights(WEIGHTS[1]); taskQC->SetUseEtaWeights(WEIGHTS[2]); + taskQC->SetnBinsMult(10000); + taskQC->SetMinMult(0.); + taskQC->SetMaxMult(10000.); + taskQC->SetApplyCorrectionForNUA(kTRUE); 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){ @@ -713,131 +421,155 @@ AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, } if (MH){ AliAnalysisTaskMixedHarmonics *taskMH = new AliAnalysisTaskMixedHarmonics("TaskMixedHarmonics",useWeights); - taskMH->SetCorrelatorInteger(1); - taskMH->SetNoOfMultipicityBins(10); - taskMH->SetMultipicityBinWidth(2); - taskMH->SetMinMultiplicity(3); + taskMH->SetHarmonic(1); // n in cos[n(phi1+phi2-2phi3)] and cos[n(psi1+psi2-2phi3)] + taskMH->SetNoOfMultipicityBins(10000); + taskMH->SetMultipicityBinWidth(1.); + taskMH->SetMinMultiplicity(1.); + taskMH->SetCalculateVsM(kTRUE); taskMH->SetCorrectForDetectorEffects(kTRUE); - //taskMH->SetUsePhiWeights(WEIGHTS[0]); - //taskMH->SetUsePtWeights(WEIGHTS[1]); - //taskMH->SetUseEtaWeights(WEIGHTS[2]); + taskMH->SetEvaluateDifferential3pCorrelator(kTRUE); // evaluate <> (Remark: two nested loops) + if(chargePOI == 0) + taskMH->SetOppositeChargesPOI(kTRUE); + else + 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->SetUsePhiWeights(WEIGHTS[0]); - //taskNL->SetUsePtWeights(WEIGHTS[1]); - //taskNL->SetUseEtaWeights(WEIGHTS[2]); + 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 <> (Remark: three nested loops) + taskNL->SetEvaluateDifferential3pCorrelator(kFALSE); // evaluate <> (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 (rptypestr == "FMD") { + AliAnalysisDataContainer *coutputFMD = + mgr->CreateContainer(Form("BackgroundCorrected_%s",centralityName.Data()), 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(Form("cobjFlowEventSimple_%s",centralityName.Data()),AliFlowEventSimple::Class(),AliAnalysisManager::kExchangeContainer); mgr->ConnectInput(taskFE,0,cinput1); mgr->ConnectOutput(taskFE,1,coutputFE); - - if (QA) { - TString qaNameRPFE = AliAnalysisManager::GetCommonFileName(); - qaNameRPFE += ":QAforRP_FE_"; - qaNameRPFE += type; - - AliAnalysisDataContainer *coutputQA1FE = - mgr->CreateContainer("QARPFE", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameRPFE); - - TString qaNamePOIFE = AliAnalysisManager::GetCommonFileName(); - qaNamePOIFE += ":QAforPOI_FE_"; - qaNamePOIFE += type; - - AliAnalysisDataContainer *coutputQA2FE = - mgr->CreateContainer("QAPOIFE", TList::Class(),AliAnalysisManager::kOutputContainer,qaNamePOIFE); - - mgr->ConnectOutput(taskFE,2,coutputQA1FE); - mgr->ConnectOutput(taskFE,3,coutputQA2FE); - } + // Create the output containers for the data produced by the analysis tasks // Connect to the input and output containers //=========================================================================== if (useWeights) { - AliAnalysisDataContainer *cinputWeights = mgr->CreateContainer("cobjWeights",TList::Class(),AliAnalysisManager::kInputContainer); + AliAnalysisDataContainer *cinputWeights = mgr->CreateContainer(Form("cobjWeights_%s",centralityName.Data()), + TList::Class(),AliAnalysisManager::kInputContainer); } if(SP) { - TString outputSP = AliAnalysisManager::GetCommonFileName(); + TString outputSP = fileName; outputSP += ":outputSPanalysis"; - outputSP+= type; - - AliAnalysisDataContainer *coutputSP = mgr->CreateContainer("cobjSP", TList::Class(),AliAnalysisManager::kOutputContainer,outputSP); + outputSP+= rptypestr; + TString cobjSP = "cobjSP"; + if((centrMin > 0)||(centrMax > 0)) { + cobjSP += "_"; cobjSP += centralityName.Data(); } + AliAnalysisDataContainer *coutputSP = mgr->CreateContainer(cobjSP.Data(), + TList::Class(),AliAnalysisManager::kOutputContainer,outputSP); mgr->ConnectInput(taskSP,0,coutputFE); mgr->ConnectOutput(taskSP,1,coutputSP); if (WEIGHTS[0]) { mgr->ConnectInput(taskSP,1,cinputWeights); cinputWeights->SetData(weightsList); - } + } } if(LYZ1SUM) { - TString outputLYZ1SUM = AliAnalysisManager::GetCommonFileName(); + TString outputLYZ1SUM = fileName; outputLYZ1SUM += ":outputLYZ1SUManalysis"; - outputLYZ1SUM+= type; - - AliAnalysisDataContainer *coutputLYZ1SUM = mgr->CreateContainer("cobjLYZ1SUM", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1SUM); - mgr->ConnectInput(taskLYZ1SUM,0,coutputFE); - mgr->ConnectOutput(taskLYZ1SUM,1,coutputLYZ1SUM); + outputLYZ1SUM+= rptypestr; + TString cobjLYZ1SUM = "cobjLYZ1SUM"; + if((centrMin > 0)||(centrMax > 0)) { + cobjLYZ1SUM += "_"; cobjLYZ1SUM += centralityName.Data(); } + AliAnalysisDataContainer *coutputLYZ1SUM = mgr->CreateContainer(cobjLYZ1SUM.Data(), + TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1SUM); + mgr->ConnectInput(taskLYZ1SUM,0,coutputFE); + mgr->ConnectOutput(taskLYZ1SUM,1,coutputLYZ1SUM); } if(LYZ1PROD) { - TString outputLYZ1PROD = AliAnalysisManager::GetCommonFileName(); + TString outputLYZ1PROD = fileName; outputLYZ1PROD += ":outputLYZ1PRODanalysis"; - outputLYZ1PROD+= type; - - AliAnalysisDataContainer *coutputLYZ1PROD = mgr->CreateContainer("cobjLYZ1PROD", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1PROD); + outputLYZ1PROD+= rptypestr; + TString cobjLYZ1PROD = "cobjLYZ1PROD"; + if((centrMin > 0)||(centrMax > 0)) { + cobjLYZ1PROD += "_"; cobjLYZ1PROD += centralityName.Data(); } + AliAnalysisDataContainer *coutputLYZ1PROD = mgr->CreateContainer(cobjLYZ1PROD.Data(), + TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1PROD); mgr->ConnectInput(taskLYZ1PROD,0,coutputFE); mgr->ConnectOutput(taskLYZ1PROD,1,coutputLYZ1PROD); } if(LYZ2SUM) { - AliAnalysisDataContainer *cinputLYZ2SUM = mgr->CreateContainer("cobjLYZ2SUMin",TList::Class(),AliAnalysisManager::kInputContainer); - TString outputLYZ2SUM = AliAnalysisManager::GetCommonFileName(); + AliAnalysisDataContainer *cinputLYZ2SUM = mgr->CreateContainer(Form("cobjLYZ2SUMin_%s",centralityName.Data()), + TList::Class(),AliAnalysisManager::kInputContainer); + TString outputLYZ2SUM = fileName; outputLYZ2SUM += ":outputLYZ2SUManalysis"; - outputLYZ2SUM+= type; - - AliAnalysisDataContainer *coutputLYZ2SUM = mgr->CreateContainer("cobjLYZ2SUM", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2SUM); + outputLYZ2SUM+= rptypestr; + TString cobjLYZ2SUM = "cobjLYZ2SUM"; + if((centrMin > 0)||(centrMax > 0)) { + cobjLYZ2SUM += "_"; cobjLYZ2SUM += centralityName.Data(); } + AliAnalysisDataContainer *coutputLYZ2SUM = mgr->CreateContainer(cobjLYZ2SUM.Data(), + TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2SUM); mgr->ConnectInput(taskLYZ2SUM,0,coutputFE); mgr->ConnectInput(taskLYZ2SUM,1,cinputLYZ2SUM); mgr->ConnectOutput(taskLYZ2SUM,1,coutputLYZ2SUM); cinputLYZ2SUM->SetData(fInputListLYZ2SUM); } if(LYZ2PROD) { - AliAnalysisDataContainer *cinputLYZ2PROD = mgr->CreateContainer("cobjLYZ2PRODin",TList::Class(),AliAnalysisManager::kInputContainer); - TString outputLYZ2PROD = AliAnalysisManager::GetCommonFileName(); + AliAnalysisDataContainer *cinputLYZ2PROD = mgr->CreateContainer(Form("cobjLYZ2PRODin_%s",centralityName.Data()), + TList::Class(),AliAnalysisManager::kInputContainer); + TString outputLYZ2PROD = fileName; outputLYZ2PROD += ":outputLYZ2PRODanalysis"; - outputLYZ2PROD+= type; - - AliAnalysisDataContainer *coutputLYZ2PROD = mgr->CreateContainer("cobjLYZ2PROD", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2PROD); + outputLYZ2PROD+= rptypestr; + TString cobjLYZ2PROD = "cobjLYZ2PROD"; + if((centrMin > 0)||(centrMax > 0)) { + cobjLYZ2PROD += "_"; cobjLYZ2PROD += centralityName.Data(); } + AliAnalysisDataContainer *coutputLYZ2PROD = mgr->CreateContainer(cobjLYZ2PROD.Data(), + TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2PROD); mgr->ConnectInput(taskLYZ2PROD,0,coutputFE); mgr->ConnectInput(taskLYZ2PROD,1,cinputLYZ2PROD); mgr->ConnectOutput(taskLYZ2PROD,1,coutputLYZ2PROD); cinputLYZ2PROD->SetData(fInputListLYZ2PROD); } if(LYZEP) { - AliAnalysisDataContainer *cinputLYZEP = mgr->CreateContainer("cobjLYZEPin",TList::Class(),AliAnalysisManager::kInputContainer); - TString outputLYZEP = AliAnalysisManager::GetCommonFileName(); + AliAnalysisDataContainer *cinputLYZEP = mgr->CreateContainer(Form("cobjLYZEPin_%s",centralityName.Data()), + TList::Class(),AliAnalysisManager::kInputContainer); + TString outputLYZEP = fileName; outputLYZEP += ":outputLYZEPanalysis"; - outputLYZEP+= type; - - AliAnalysisDataContainer *coutputLYZEP = mgr->CreateContainer("cobjLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZEP); + outputLYZEP+= rptypestr; + TString cobjLYZEP = "cobjLYZEP"; + if((centrMin > 0)||(centrMax > 0)) { + cobjLYZEP += "_"; cobjLYZEP += centralityName.Data(); } + AliAnalysisDataContainer *coutputLYZEP = mgr->CreateContainer(cobjLYZEP.Data(), + TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZEP); mgr->ConnectInput(taskLYZEP,0,coutputFE); mgr->ConnectInput(taskLYZEP,1,cinputLYZEP); mgr->ConnectOutput(taskLYZEP,1,coutputLYZEP); cinputLYZEP->SetData(fInputListLYZEP); } if(GFC) { - TString outputGFC = AliAnalysisManager::GetCommonFileName(); + TString outputGFC = fileName; outputGFC += ":outputGFCanalysis"; - outputGFC+= type; - - AliAnalysisDataContainer *coutputGFC = mgr->CreateContainer("cobjGFC", TList::Class(),AliAnalysisManager::kOutputContainer,outputGFC); + outputGFC+= rptypestr; + TString cobjGFC = "cobjLYZ1PROD"; + if((centrMin > 0)||(centrMax > 0)) { + cobjGFC += "_"; cobjGFC += centralityName.Data(); } + AliAnalysisDataContainer *coutputGFC = mgr->CreateContainer(cobjGFC.Data(), + TList::Class(),AliAnalysisManager::kOutputContainer,outputGFC); mgr->ConnectInput(taskGFC,0,coutputFE); mgr->ConnectOutput(taskGFC,1,coutputGFC); if (useWeights) { @@ -846,24 +578,30 @@ AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, } } if(QC) { - TString outputQC = AliAnalysisManager::GetCommonFileName(); + TString outputQC = fileName; outputQC += ":outputQCanalysis"; - outputQC+= type; - - AliAnalysisDataContainer *coutputQC = mgr->CreateContainer("cobjQC", TList::Class(),AliAnalysisManager::kOutputContainer,outputQC); + outputQC+= rptypestr; + TString cobjQC = "cobjQC"; + if((centrMin > 0)||(centrMax > 0)) { + cobjQC += "_"; cobjQC += centralityName.Data(); } + AliAnalysisDataContainer *coutputQC = mgr->CreateContainer(cobjQC.Data(), + TList::Class(),AliAnalysisManager::kOutputContainer,outputQC); mgr->ConnectInput(taskQC,0,coutputFE); mgr->ConnectOutput(taskQC,1,coutputQC); if (useWeights) { mgr->ConnectInput(taskQC,1,cinputWeights); cinputWeights->SetData(weightsList); - } + } } if(FQD) { - TString outputFQD = AliAnalysisManager::GetCommonFileName(); + TString outputFQD = fileName; outputFQD += ":outputFQDanalysis"; - outputFQD+= type; - - AliAnalysisDataContainer *coutputFQD = mgr->CreateContainer("cobjFQD", TList::Class(),AliAnalysisManager::kOutputContainer,outputFQD); + outputFQD+= rptypestr; + TString cobjFQD = "cobjFQD"; + if((centrMin > 0)||(centrMax > 0)) { + cobjFQD += "_"; cobjFQD += centralityName.Data(); } + AliAnalysisDataContainer *coutputFQD = mgr->CreateContainer(cobjFQD.Data(), + TList::Class(),AliAnalysisManager::kOutputContainer,outputFQD); mgr->ConnectInput(taskFQD,0,coutputFE); mgr->ConnectOutput(taskFQD,1,coutputFQD); if(useWeights) { @@ -872,20 +610,26 @@ AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, } } if(MCEP) { - TString outputMCEP = AliAnalysisManager::GetCommonFileName(); + TString outputMCEP = fileName; outputMCEP += ":outputMCEPanalysis"; - outputMCEP+= type; - - AliAnalysisDataContainer *coutputMCEP = mgr->CreateContainer("cobjMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputMCEP); - mgr->ConnectInput(taskMCEP,0,coutputFE); + outputMCEP+= rptypestr; + TString cobjMCEP = "cobjMCEP"; + if((centrMin > 0)||(centrMax > 0)) { + cobjMCEP += "_"; cobjMCEP += centralityName.Data(); } + AliAnalysisDataContainer *coutputMCEP = mgr->CreateContainer(cobjMCEP.Data(), + TList::Class(),AliAnalysisManager::kOutputContainer,outputMCEP); + mgr->ConnectInput(taskMCEP,0,coutputFE); mgr->ConnectOutput(taskMCEP,1,coutputMCEP); } if(MH) { - TString outputMH = AliAnalysisManager::GetCommonFileName(); + TString outputMH = fileName; outputMH += ":outputMHanalysis"; - outputMH += type; - - AliAnalysisDataContainer *coutputMH = mgr->CreateContainer("cobjMH", TList::Class(),AliAnalysisManager::kOutputContainer,outputMH); + outputMH += rptypestr; + TString cobjMH = "cobjMH"; + if((centrMin > 0)||(centrMax > 0)) { + cobjMH += "_"; cobjMH += centralityName.Data(); } + AliAnalysisDataContainer *coutputMH = mgr->CreateContainer(cobjMH.Data(), + TList::Class(),AliAnalysisManager::kOutputContainer,outputMH); mgr->ConnectInput(taskMH,0,coutputFE); mgr->ConnectOutput(taskMH,1,coutputMH); //if (useWeights) { @@ -894,25 +638,57 @@ AliAnalysisTaskFlowEvent* AddTaskFlow(TString type, Bool_t* METHODS, Bool_t QA, //} } if(NL) { - TString outputNL = AliAnalysisManager::GetCommonFileName(); + TString outputNL = fileName; outputNL += ":outputNLanalysis"; - outputNL += type; - - AliAnalysisDataContainer *coutputNL = mgr->CreateContainer("cobjNL", TList::Class(),AliAnalysisManager::kOutputContainer,outputNL); - mgr->ConnectInput(taskNL,0,coutputFE); - mgr->ConnectOutput(taskNL,1,coutputNL); + outputNL += rptypestr; + TString cobjNL = "cobjNL"; + if((centrMin > 0)||(centrMax > 0)) { + cobjNL += "_"; cobjNL += centralityName.Data(); } + AliAnalysisDataContainer *coutputNL = mgr->CreateContainer(cobjNL.Data(), + 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 - //=========================================================================== - return taskFE; - - - + /////////////////////////////////////////////////////////////////////////////////////////// + if (runQAtask) + { + AliAnalysisTaskQAflow* taskQAflow = new AliAnalysisTaskQAflow("TaskQAflow"); + taskQAflow->SetEventCuts(cutsEvent); + taskQAflow->SetTrackCuts(cutsRP); + taskQAflow->SetFillNTuple(FillQAntuple); + taskQAflow->SetDoCorrelations(DoQAcorrelations); + mgr->AddTask(taskQAflow); + + if((centrMin > 0)||(centrMax > 0)) + Printf("centralityName %s",centralityName.Data()); + TString taskQAoutputFileName(fileNameBase); + taskQAoutputFileName.Append("_QA.root"); + + TString taskQAname = "flowQA"; + if((centrMin > 0)||(centrMax > 0)) { + taskQAname += "_"; taskQAname += centralityName.Data();} + AliAnalysisDataContainer* coutputQAtask = mgr->CreateContainer(taskQAname.Data(), + TObjArray::Class(), + AliAnalysisManager::kOutputContainer, + taskQAoutputFileName); + + TString taskQATreeName = "flowQAntuple"; + if((centrMin > 0)||(centrMax > 0)) { + taskQATreeName += "_"; taskQATreeName += centralityName.Data();} + AliAnalysisDataContainer* coutputQAtaskTree = mgr->CreateContainer(taskQATreeName.data(), + TNtuple::Class(), + AliAnalysisManager::kOutputContainer, + taskQAoutputFileName); + mgr->ConnectInput(taskQAflow,0,mgr->GetCommonInputContainer()); + mgr->ConnectInput(taskQAflow,1,coutputFE); + mgr->ConnectOutput(taskQAflow,1,coutputQAtask); + if (FillQAntuple) mgr->ConnectOutput(taskQAflow,2,coutputQAtaskTree); + } }