//
/////////////////////////////////////////////////////////////////////////////////////////////
-// 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;
-
-// 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;
-
-// generate the control ntuple
-Bool_t FillQAntuple=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 = kFALSE; // 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, kESD_TPConly, kESD_SPDtracklet
-AliFlowTrackCuts::trackParameterType rptype = AliFlowTrackCuts::kESD_TPConly;
-AliFlowTrackCuts::trackParameterType poitype = AliFlowTrackCuts::kESD_TPConly;
-
-//---------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);
-
-void AddTaskFlowCentrality( Int_t refMultMin=0,
- Int_t refMultMax=1e10,
- TString fileNameBase="AnalysisResults",
- Int_t binnumber=0 )
+void AddTaskFlowCentrality( Float_t centrMin=0.,
+ Float_t centrMax=100.,
+ TString fileNameBase="AnalysisResults" )
{
+ // 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;
+
+ // 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;
+
+ // separate QA task
+ 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 = kFALSE; // 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 fileName(fileNameBase);
- fileName+=binnumber;
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();
- cutsEvent->SetRefMultRange(refMultMin,refMultMax);
- cutsEvent->SetRefMultMethod(AliFlowEventCuts::kTPConly);
- //cutsEvent->SetRefMultMethod(AliFlowEventCuts::kSPDtracklets);
- //cutsEvent->SetRefMultMethod(AliFlowEventCuts::kV0);
- cutsEvent->SetNContributorsRange(1);
- cutsEvent->SetPrimaryVertexZrange(-10.,10.);
+ AliFlowEventCuts* cutsEvent = new AliFlowEventCuts("event cuts");
+ cutsEvent->SetCentralityPercentileRange(centrMin,centrMax);
+ cutsEvent->SetCentralityPercentileMethod(AliFlowEventCuts::kV0);
+ cutsEvent->SetRefMultMethod(AliFlowEventCuts::kV0);
+ //cutsEvent->SetCentralityPercentileMethod(AliFlowEventCuts::kSPD1tracklets);
+ cutsEvent->SetNContributorsRange(2);
+ cutsEvent->SetPrimaryVertexZrange(-7.,7.);
+ cutsEvent->SetCutSPDvertexerAnomaly(); //"Francesco's cut"
+ cutsEvent->SetCutZDCtiming();
+ //cutsEvent->SetCutTPCmultiplicityOutliers();
+ //cutsEvent->SetUseCentralityUnchecked();
// RP TRACK CUTS:
- AliFlowTrackCuts* cutsRP = new AliFlowTrackCuts();
+ AliFlowTrackCuts* cutsRP = new AliFlowTrackCuts("GlobalRP");
cutsRP->SetParamType(rptype);
cutsRP->SetParamMix(rpmix);
- cutsRP->SetPtRange(0.2,10.);
+ cutsRP->SetPtRange(0.2,5.);
cutsRP->SetEtaRange(-0.8,0.8);
- cutsRP->SetRequireCharge(kTRUE);
+ //cutsRP->SetRequireCharge(kTRUE);
//cutsRP->SetCharge(chargeRP);
//cutsRP->SetPID(PdgRP);
- cutsRP->SetMinNClustersTPC(50);
+ cutsRP->SetMinNClustersTPC(70);
+ cutsRP->SetMinChi2PerClusterTPC(0.1);
cutsRP->SetMaxChi2PerClusterTPC(4.0);
- //cutsRP->SetMinNClustersITS(2);
+ cutsRP->SetMinNClustersITS(2);
+ cutsRP->SetRequireITSRefit(kTRUE);
+ cutsRP->SetRequireTPCRefit(kTRUE);
//cutsRP->SetMaxChi2PerClusterITS(1.e+09);
- cutsRP->SetMaxDCAToVertexXY(2.4);
- //cutsRP->SetMaxDCAToVertexZ(3.2);
+ cutsRP->SetMaxDCAToVertexXY(0.3);
+ cutsRP->SetMaxDCAToVertexZ(0.3);
//cutsRP->SetDCAToVertex2D(kTRUE);
//cutsRP->SetMaxNsigmaToVertex(1.e+10);
//cutsRP->SetRequireSigmaToVertex(kFALSE);
- //cutsRP->SetAcceptKinkDaughters(kFALSE);
+ cutsRP->SetAcceptKinkDaughters(kFALSE);
+ cutsRP->SetMinimalTPCdedx(10.);
// POI TRACK CUTS:
- AliFlowTrackCuts* cutsPOI = new AliFlowTrackCuts();
+ AliFlowTrackCuts* cutsPOI = new AliFlowTrackCuts("GlobalPOI");
cutsPOI->SetParamType(poitype);
cutsPOI->SetParamMix(poimix);
- cutsPOI->SetPtRange(0.1,100.);
- cutsPOI->SetEtaRange(-0.9,0.9);
- cutsPOI->SetRequireCharge(kTRUE);
+ cutsPOI->SetPtRange(0.0,10.);
+ cutsPOI->SetEtaRange(-1.2,1.2);
+ //cutsPOI->SetRequireCharge(kTRUE);
//cutsPOI->SetCharge(chargeRP);
//cutsPOI->SetPID(PdgRP);
- //cutsPOI->SetMinNClustersTPC(80);
- //cutsPOI->SetMaxChi2PerClusterTPC(4.0);
- //cutsPOI->SetMinNClustersITS(2);
+ 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(2.4);
- //cutsPOI->SetMaxDCAToVertexZ(3.2);
+ cutsPOI->SetMaxDCAToVertexXY(0.3);
+ cutsPOI->SetMaxDCAToVertexZ(0.3);
//cutsPOI->SetDCAToVertex2D(kTRUE);
//cutsPOI->SetMaxNsigmaToVertex(1.e+10);
//cutsPOI->SetRequireSigmaToVertex(kFALSE);
- //cutsPOI->SetAcceptKinkDaughters(kFALSE);
-
+ cutsPOI->SetAcceptKinkDaughters(kFALSE);
+ cutsRP->SetMinimalTPCdedx(10.);
+ //cutsPOI->SetPID(AliPID::kProton, AliFlowTrackCuts::kTOFpid);
+ //cutsPOI->SetPID(AliPID::kPion, AliFlowTrackCuts::kTPCpid);
+ //cutsPOI->SetPID(AliPID::kProton, AliFlowTrackCuts::kTPCdedx);
+ //cutsPOI->SetPID(AliPID::kProton, AliFlowTrackCuts::kTOFbeta);
+ //cutsPOI->SetAllowTOFmismatch(kFALSE);
+ //iexample: francesco's tunig 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);
+
+ TString outputSlotName("");
+ outputSlotName+=Form("%.0f",centrMin);
+ outputSlotName+="-";
+ outputSlotName+=Form("%.0f",centrMax);
+ outputSlotName+=" ";
+ outputSlotName+=cutsRP->GetName();
Bool_t useWeights = WEIGHTS[0] || WEIGHTS[1] || WEIGHTS[2];
if (useWeights) cout<<"Weights are used"<<endl;
break;
}
else {
- TList* fInputListLYZ2SUM = (TList*)fInputFileLYZ2SUM->Get("cobjLYZ1SUM");
+ TList* fInputListLYZ2SUM = (TList*)fInputFileLYZ2SUM->Get("LYZ1SUM");
if (!fInputListLYZ2SUM) {cout<<"list is NULL pointer!"<<endl;}
}
cout<<"LYZ2SUM input file/list read..."<<endl;
break;
}
else {
- TList* fInputListLYZ2PROD = (TList*)fInputFileLYZ2PROD->Get("cobjLYZ1PROD");
+ TList* fInputListLYZ2PROD = (TList*)fInputFileLYZ2PROD->Get("LYZ1PROD");
if (!fInputListLYZ2PROD) {cout<<"list is NULL pointer!"<<endl;}
}
cout<<"LYZ2PROD input file/list read..."<<endl;
break;
}
else {
- TList* fInputListLYZEP = (TList*)fInputFileLYZEP->Get("cobjLYZ2SUM");
+ TList* fInputListLYZEP = (TList*)fInputFileLYZEP->Get("LYZ2SUM");
if (!fInputListLYZEP) {cout<<"list is NULL pointer!"<<endl;}
}
cout<<"LYZEP input file/list read..."<<endl;
}
taskFE->SetSubeventEtaRange(minA, maxA, minB, maxB);
if (UsePhysicsSelection) {
+ //taskFE->SelectCollisionCandidates(AliVEvent::kUserDefined);
taskFE->SelectCollisionCandidates(AliVEvent::kMB);
cout<<"Using Physics Selection"<<endl;
}
// Pass cuts for RPs and POIs to the task:
taskFE->SetCutsRP(cutsRP);
taskFE->SetCutsPOI(cutsPOI);
-
-
+ if (cutsRP->GetParamType()==AliFlowTrackCuts::kV0)
+ {
+ //TODO: since this is set in a static object all analyses in an analysis train
+ //will be affected.
+ taskFE->SetHistWeightvsPhiMin(0.);
+ taskFE->SetHistWeightvsPhiMax(200.);
+ }
// Create the analysis tasks, add them to the manager.
//===========================================================================
if (SP){
AliAnalysisTaskScalarProduct *taskSP = new AliAnalysisTaskScalarProduct("TaskScalarProduct",WEIGHTS[0]);
taskSP->SetRelDiffMsub(1.0);
- taskSP->SetApplyCorrectionForNUA(kTRUE);
+ taskSP->SetApplyCorrectionForNUA(kFALSE);
+ //taskSP->SetHarmonic(2); // default is v2
mgr->AddTask(taskSP);
}
if (LYZ1SUM){
taskQC->SetUsePhiWeights(WEIGHTS[0]);
taskQC->SetUsePtWeights(WEIGHTS[1]);
taskQC->SetUseEtaWeights(WEIGHTS[2]);
+ taskQC->SetCalculateCumulantsVsM(kFALSE);
taskQC->SetnBinsMult(10000);
taskQC->SetMinMult(0.);
taskQC->SetMaxMult(10000.);
- taskQC->SetApplyCorrectionForNUA(kTRUE);
+ //taskQC->SetHarmonic(2); // default is v2
+ taskQC->SetApplyCorrectionForNUA(kFALSE);
+ taskQC->SetFillMultipleControlHistograms(kFALSE);
mgr->AddTask(taskQC);
}
if (FQD){
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->SetNoOfMultipicityBins(10000);
+ taskMH->SetMultipicityBinWidth(1.);
+ taskMH->SetMinMultiplicity(1.);
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(taskNL);
}
- AliAnalysisTaskQAflow* taskQAflow = new AliAnalysisTaskQAflow("TaskQAflow");
- taskQAflow->SetEventCuts(cutsEvent);
- taskQAflow->SetTrackCuts(cutsRP);
- taskQAflow->SetFillNTuple(FillQAntuple);
- mgr->AddTask(taskQAflow);
-
// Create the output container for the data produced by the task
// Connect to the input and output containers
//===========================================================================
if (rptypestr == "FMD") {
AliAnalysisDataContainer *coutputFMD =
- mgr->CreateContainer(Form("BackgroundCorrected_%s",fileName.Data()), TList::Class(), AliAnalysisManager::kExchangeContainer);
+ mgr->CreateContainer(Form("BackgroundCorrected_%s",outputSlotName.Data()), TList::Class(), AliAnalysisManager::kExchangeContainer);
//input and output taskFMD
mgr->ConnectInput(taskfmd, 0, cinput1);
mgr->ConnectOutput(taskfmd, 1, coutputFMD);
}
AliAnalysisDataContainer *coutputFE =
- mgr->CreateContainer(Form("cobjFlowEventSimple_%s",fileName.Data()), AliFlowEventSimple::Class(),AliAnalysisManager::kExchangeContainer);
+ mgr->CreateContainer(Form("FlowEventSimple_%s",outputSlotName.Data()),AliFlowEventSimple::Class(),AliAnalysisManager::kExchangeContainer);
mgr->ConnectInput(taskFE,0,cinput1);
mgr->ConnectOutput(taskFE,1,coutputFE);
-
+
+ if (taskFE->GetQAOn())
+ {
+ AliAnalysisDataContainer* coutputFEQA =
+ mgr->CreateContainer(Form("QA %s",outputSlotName.Data()), TList::Class(),AliAnalysisManager::kOutputContainer,Form("%s:QA %s",fileName,rptypestr));
+ mgr->ConnectOutput(taskFE,2,coutputFEQA);
+ }
// 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(Form("cobjWeights_%s",fileName.Data()),
+ AliAnalysisDataContainer *cinputWeights = mgr->CreateContainer(Form("Weights_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kInputContainer);
}
TString outputSP = fileName;
outputSP += ":outputSPanalysis";
outputSP+= rptypestr;
- AliAnalysisDataContainer *coutputSP = mgr->CreateContainer(Form("cobjSP_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputSP = mgr->CreateContainer(Form("SP_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputSP);
mgr->ConnectInput(taskSP,0,coutputFE);
mgr->ConnectOutput(taskSP,1,coutputSP);
TString outputLYZ1SUM = fileName;
outputLYZ1SUM += ":outputLYZ1SUManalysis";
outputLYZ1SUM+= rptypestr;
- AliAnalysisDataContainer *coutputLYZ1SUM = mgr->CreateContainer(Form("cobjLYZ1SUM_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputLYZ1SUM = mgr->CreateContainer(Form("LYZ1SUM_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1SUM);
mgr->ConnectInput(taskLYZ1SUM,0,coutputFE);
mgr->ConnectOutput(taskLYZ1SUM,1,coutputLYZ1SUM);
TString outputLYZ1PROD = fileName;
outputLYZ1PROD += ":outputLYZ1PRODanalysis";
outputLYZ1PROD+= rptypestr;
- AliAnalysisDataContainer *coutputLYZ1PROD = mgr->CreateContainer(Form("cobjLYZ1PROD_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputLYZ1PROD = mgr->CreateContainer(Form("LYZ1PROD_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1PROD);
mgr->ConnectInput(taskLYZ1PROD,0,coutputFE);
mgr->ConnectOutput(taskLYZ1PROD,1,coutputLYZ1PROD);
}
if(LYZ2SUM) {
- AliAnalysisDataContainer *cinputLYZ2SUM = mgr->CreateContainer(Form("cobjLYZ2SUMin_%s",fileName.Data()),
+ AliAnalysisDataContainer *cinputLYZ2SUM = mgr->CreateContainer(Form("LYZ2SUMin_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kInputContainer);
TString outputLYZ2SUM = fileName;
outputLYZ2SUM += ":outputLYZ2SUManalysis";
outputLYZ2SUM+= rptypestr;
- AliAnalysisDataContainer *coutputLYZ2SUM = mgr->CreateContainer(Form("cobjLYZ2SUM_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputLYZ2SUM = mgr->CreateContainer(Form("LYZ2SUM_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2SUM);
mgr->ConnectInput(taskLYZ2SUM,0,coutputFE);
mgr->ConnectInput(taskLYZ2SUM,1,cinputLYZ2SUM);
cinputLYZ2SUM->SetData(fInputListLYZ2SUM);
}
if(LYZ2PROD) {
- AliAnalysisDataContainer *cinputLYZ2PROD = mgr->CreateContainer(Form("cobjLYZ2PRODin_%s",fileName.Data()),
+ AliAnalysisDataContainer *cinputLYZ2PROD = mgr->CreateContainer(Form("LYZ2PRODin_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kInputContainer);
TString outputLYZ2PROD = fileName;
outputLYZ2PROD += ":outputLYZ2PRODanalysis";
outputLYZ2PROD+= rptypestr;
- AliAnalysisDataContainer *coutputLYZ2PROD = mgr->CreateContainer(Form("cobjLYZ2PROD_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputLYZ2PROD = mgr->CreateContainer(Form("LYZ2PROD_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2PROD);
mgr->ConnectInput(taskLYZ2PROD,0,coutputFE);
mgr->ConnectInput(taskLYZ2PROD,1,cinputLYZ2PROD);
cinputLYZ2PROD->SetData(fInputListLYZ2PROD);
}
if(LYZEP) {
- AliAnalysisDataContainer *cinputLYZEP = mgr->CreateContainer(Form("cobjLYZEPin_%s",fileName.Data()),
+ AliAnalysisDataContainer *cinputLYZEP = mgr->CreateContainer(Form("LYZEPin_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kInputContainer);
TString outputLYZEP = fileName;
outputLYZEP += ":outputLYZEPanalysis";
outputLYZEP+= rptypestr;
- AliAnalysisDataContainer *coutputLYZEP = mgr->CreateContainer(Form("cobjLYZEP_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputLYZEP = mgr->CreateContainer(Form("LYZEP_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZEP);
mgr->ConnectInput(taskLYZEP,0,coutputFE);
mgr->ConnectInput(taskLYZEP,1,cinputLYZEP);
outputGFC += ":outputGFCanalysis";
outputGFC+= rptypestr;
- AliAnalysisDataContainer *coutputGFC = mgr->CreateContainer(Form("cobjGFC_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputGFC = mgr->CreateContainer(Form("GFC_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputGFC);
mgr->ConnectInput(taskGFC,0,coutputFE);
mgr->ConnectOutput(taskGFC,1,coutputGFC);
outputQC += ":outputQCanalysis";
outputQC+= rptypestr;
- AliAnalysisDataContainer *coutputQC = mgr->CreateContainer(Form("cobjQC_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputQC = mgr->CreateContainer(Form("QC_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputQC);
mgr->ConnectInput(taskQC,0,coutputFE);
mgr->ConnectOutput(taskQC,1,coutputQC);
outputFQD += ":outputFQDanalysis";
outputFQD+= rptypestr;
- AliAnalysisDataContainer *coutputFQD = mgr->CreateContainer(Form("cobjFQD_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputFQD = mgr->CreateContainer(Form("FQD_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputFQD);
mgr->ConnectInput(taskFQD,0,coutputFE);
mgr->ConnectOutput(taskFQD,1,coutputFQD);
outputMCEP += ":outputMCEPanalysis";
outputMCEP+= rptypestr;
- AliAnalysisDataContainer *coutputMCEP = mgr->CreateContainer(Form("cobjMCEP_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputMCEP = mgr->CreateContainer(Form("MCEP_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputMCEP);
mgr->ConnectInput(taskMCEP,0,coutputFE);
mgr->ConnectOutput(taskMCEP,1,coutputMCEP);
outputMH += ":outputMHanalysis";
outputMH += rptypestr;
- AliAnalysisDataContainer *coutputMH = mgr->CreateContainer(Form("cobjMH_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputMH = mgr->CreateContainer(Form("MH_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputMH);
mgr->ConnectInput(taskMH,0,coutputFE);
mgr->ConnectOutput(taskMH,1,coutputMH);
outputNL += ":outputNLanalysis";
outputNL += rptypestr;
- AliAnalysisDataContainer *coutputNL = mgr->CreateContainer(Form("cobjNL_%s",fileName.Data()),
+ AliAnalysisDataContainer *coutputNL = mgr->CreateContainer(Form("NL_%s",outputSlotName.Data()),
TList::Class(),AliAnalysisManager::kOutputContainer,outputNL);
mgr->ConnectInput(taskNL,0,coutputFE);
mgr->ConnectOutput(taskNL,1,coutputNL);
//}
}
- TString taskQAoutputFileName(fileNameBase);
- taskQAoutputFileName+=binnumber;
- taskQAoutputFileName.Append("_QA.root");
- AliAnalysisDataContainer* coutputQAtask = mgr->CreateContainer(Form("flowQA_%i",binnumber),
- TObjArray::Class(),
- AliAnalysisManager::kOutputContainer,
- taskQAoutputFileName);
- AliAnalysisDataContainer* coutputQAtaskTree = mgr->CreateContainer(Form("flowQAntuple_%i",binnumber),
- TTree::Class(),
- AliAnalysisManager::kOutputContainer,
- taskQAoutputFileName);
- mgr->ConnectInput(taskQAflow,0,mgr->GetCommonInputContainer());
- mgr->ConnectInput(taskQAflow,1,coutputFE);
- mgr->ConnectOutput(taskQAflow,0,coutputQAtaskTree);
- mgr->ConnectOutput(taskQAflow,1,coutputQAtask);
+ ///////////////////////////////////////////////////////////////////////////////////////////
+ if (runQAtask)
+ {
+ AliAnalysisTaskQAflow* taskQAflow = new AliAnalysisTaskQAflow("TaskQAflow");
+ taskQAflow->SetEventCuts(cutsEvent);
+ taskQAflow->SetTrackCuts(cutsRP);
+ taskQAflow->SetFillNTuple(FillQAntuple);
+ taskQAflow->SetDoCorrelations(DoQAcorrelations);
+ mgr->AddTask(taskQAflow);
+
+ Printf("outputSlotName %s",outputSlotName.Data());
+ TString taskQAoutputFileName(fileNameBase);
+ taskQAoutputFileName.Append("_QA.root");
+ AliAnalysisDataContainer* coutputQAtask = mgr->CreateContainer(Form("flowQA_%s",outputSlotName.Data()),
+ TObjArray::Class(),
+ AliAnalysisManager::kOutputContainer,
+ taskQAoutputFileName);
+ AliAnalysisDataContainer* coutputQAtaskTree = mgr->CreateContainer(Form("flowQAntuple_%s",outputSlotName.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);
+ }
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff