//
/////////////////////////////////////////////////////////////////////////////////////////////
+// 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.5;
+Double_t minB = 0.5;
+Double_t maxB = 0.9;
+
+
+// use physics selection class
+Bool_t UsePhysicsSelection = kTRUE;
// SETTING THE CUTS
const Int_t multminESD = 1; //used for CORRFW cuts
const Int_t multmaxESD = 1000000; //used for CORRFW cuts
-//Bool_t UseMultCut = kTRUE;
-Bool_t UseMultCut = kFALSE;
-const Int_t multmin = 10; //used for AliFlowEventSimple (to set the centrality)
-const Int_t multmax = 40; //used for AliFlowEventSimple (to set the centrality)
+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----------
+// 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;
}
}
- if (LYZ2SUM){
- // read the output file from LYZ1SUM
- TString inputFileNameLYZ2SUM = "outputLYZ1SUManalysis" ;
- inputFileNameLYZ2SUM += type;
- inputFileNameLYZ2SUM += ".root";
- cout<<"The input file is "<<inputFileNameLYZ2SUM.Data()<<endl;
- TFile* fInputFileLYZ2SUM = new TFile(inputFileNameLYZ2SUM.Data(),"READ");
- if(!fInputFileLYZ2SUM || fInputFileLYZ2SUM->IsZombie()) {
- cerr << " ERROR: To run LYZ2SUM you need the output file from LYZ1SUM. This file is not there! Please run LYZ1SUM first." << endl ;
- break;
+ //LYZ2
+ if (LYZ2SUM || LYZ2PROD) {
+ //read the outputfile of the first run
+ TString outputFileName = "AnalysisResults1.root";
+ TString pwd(gSystem->pwd());
+ pwd+="/";
+ pwd+=outputFileName.Data();
+ TFile *outputFile = NULL;
+ if(gSystem->AccessPathName(pwd.Data(),kFileExists)) {
+ cout<<"WARNING: You do not have an output file:"<<endl;
+ cout<<" "<<pwd.Data()<<endl;
+ exit(0);
+ } else {
+ outputFile = TFile::Open(pwd.Data(),"READ");
}
- else {
- TList* fInputListLYZ2SUM = (TList*)fInputFileLYZ2SUM->Get("cobjLYZ1SUM");
- if (!fInputListLYZ2SUM) {cout<<"list is NULL pointer!"<<endl;}
- }
- cout<<"LYZ2SUM input file/list read..."<<endl;
- }
-if (LYZ2PROD){
- // read the output file from LYZ1PROD
- TString inputFileNameLYZ2PROD = "outputLYZ1PRODanalysis" ;
- inputFileNameLYZ2PROD += type;
- inputFileNameLYZ2PROD += ".root";
- cout<<"The input file is "<<inputFileNameLYZ2PROD.Data()<<endl;
- TFile* fInputFileLYZ2PROD = new TFile(inputFileNameLYZ2PROD.Data(),"READ");
- if(!fInputFileLYZ2PROD || fInputFileLYZ2PROD->IsZombie()) {
- cerr << " ERROR: To run LYZ2PROD you need the output file from LYZ1PROD. This file is not there! Please run LYZ1PROD first." << endl ;
- break;
+
+ if (LYZ2SUM){
+ // read the output directory from LYZ1SUM
+ TString inputFileNameLYZ2SUM = "outputLYZ1SUManalysis" ;
+ inputFileNameLYZ2SUM += type;
+ cout<<"The input directory is "<<inputFileNameLYZ2SUM.Data()<<endl;
+ TFile* fInputFileLYZ2SUM = (TFile*)outputFile->FindObjectAny(inputFileNameLYZ2SUM.Data());
+ if(!fInputFileLYZ2SUM || fInputFileLYZ2SUM->IsZombie()) {
+ cerr << " ERROR: To run LYZ2SUM you need the output file from LYZ1SUM. This file is not there! Please run LYZ1SUM first." << endl ;
+ break;
+ }
+ else {
+ TList* fInputListLYZ2SUM = (TList*)fInputFileLYZ2SUM->Get("cobjLYZ1SUM");
+ if (!fInputListLYZ2SUM) {cout<<"list is NULL pointer!"<<endl;}
+ }
+ cout<<"LYZ2SUM input file/list read..."<<endl;
}
- else {
- TList* fInputListLYZ2PROD = (TList*)fInputFileLYZ2PROD->Get("cobjLYZ1PROD");
- if (!fInputListLYZ2PROD) {cout<<"list is NULL pointer!"<<endl;}
+
+ if (LYZ2PROD){
+ // read the output directory from LYZ1PROD
+ TString inputFileNameLYZ2PROD = "outputLYZ1PRODanalysis" ;
+ inputFileNameLYZ2PROD += type;
+ cout<<"The input directory is "<<inputFileNameLYZ2PROD.Data()<<endl;
+ TFile* fInputFileLYZ2PROD = (TFile*)outputFile->FindObjectAny(inputFileNameLYZ2PROD.Data());
+ if(!fInputFileLYZ2PROD || fInputFileLYZ2PROD->IsZombie()) {
+ cerr << " ERROR: To run LYZ2PROD you need the output file from LYZ1PROD. This file is not there! Please run LYZ1PROD first." << endl ;
+ break;
+ }
+ else {
+ TList* fInputListLYZ2PROD = (TList*)fInputFileLYZ2PROD->Get("cobjLYZ1PROD");
+ if (!fInputListLYZ2PROD) {cout<<"list is NULL pointer!"<<endl;}
+ }
+ cout<<"LYZ2PROD input file/list read..."<<endl;
}
- cout<<"LYZ2PROD input file/list read..."<<endl;
}
-
+
+
if (LYZEP) {
+ //read the outputfile of the second run
+ TString outputFileName = "AnalysisResults2.root";
+ TString pwd(gSystem->pwd());
+ pwd+="/";
+ pwd+=outputFileName.Data();
+ TFile *outputFile = NULL;
+ if(gSystem->AccessPathName(pwd.Data(),kFileExists)) {
+ cout<<"WARNING: You do not have an output file:"<<endl;
+ cout<<" "<<pwd.Data()<<endl;
+ exit(0);
+ } else {
+ outputFile = TFile::Open(pwd.Data(),"READ");
+ }
+
// read the output file from LYZ2SUM
TString inputFileNameLYZEP = "outputLYZ2SUManalysis" ;
inputFileNameLYZEP += type;
- inputFileNameLYZEP += ".root";
cout<<"The input file is "<<inputFileNameLYZEP.Data()<<endl;
- TFile* fInputFileLYZEP = new TFile(inputFileNameLYZEP.Data(),"READ");
+ TFile* fInputFileLYZEP = (TFile*)outputFile->FindObjectAny(inputFileNameLYZEP.Data());
if(!fInputFileLYZEP || fInputFileLYZEP->IsZombie()) {
cerr << " ERROR: To run LYZEP you need the output file from LYZ2SUM. This file is not there! Please run LYZ2SUM first." << endl ;
break;
}
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);}
+ taskFE->SetMaxMult(multmax);
+ }
+ taskFE->SetSubeventEtaRange(minA, maxA, minB, maxB);
+ if (UsePhysicsSelection) {
+ taskFE->SelectCollisionCandidates();
+ cout<<"Using Physics Selection"<<endl;
+ }
mgr->AddTask(taskFE);
}
else {
- taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",kFALSE);
+ if(AddToEvent) {
+ taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",rptype,kFALSE,1);
+ taskFE->SetEllipticFlowValue(ellipticFlow); } //TEST
+ else {taskFE = new AliAnalysisTaskFlowEvent("TaskFlowEvent",rptype,kFALSE); }
taskFE->SetAnalysisType(type);
if (UseMultCut) {
taskFE->SetMinMult(multmin);
- taskFE->SetMaxMult(multmax); }
+ taskFE->SetMaxMult(multmax);
+ }
+ taskFE->SetSubeventEtaRange(minA, maxA, minB, maxB);
+ if (UsePhysicsSelection) {
+ taskFE->SelectCollisionCandidates();
+ cout<<"Using Physics Selection"<<endl;
+ }
mgr->AddTask(taskFE);
}
//----------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);
}
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);
}
//----------Create Cut Lists----------
printf("CREATE EVENT CUTS\n");
TObjArray* mcEventList = new TObjArray(0);
- if (UseMultCutforESD) mcEventList->AddLast(mcEventCuts);//cut on mult
+ if (UseMultCutforESD) mcEventList->AddLast(mcEventCuts);//cut on mult and vertex
TObjArray* recEventList = new TObjArray(0);
- if (UseMultCutforESD) recEventList->AddLast(recEventCuts);//cut on mult
+ if (UseMultCutforESD) recEventList->AddLast(recEventCuts);//cut on mult and vertex
printf("CREATE MC KINE CUTS\n");
TObjArray* mcListRP = new TObjArray(0);
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
// Create the analysis tasks, add them to the manager.
//===========================================================================
if (SP){
- AliAnalysisTaskScalarProduct *taskSP = new AliAnalysisTaskScalarProduct("TaskScalarProduct");
+ 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,0,coutputFE);
+ mgr->ConnectOutput(taskFE,1,coutputFE);
if (QA) {
TString qaNameRPFE = AliAnalysisManager::GetCommonFileName();
AliAnalysisDataContainer *coutputQA2FE =
mgr->CreateContainer("QAPOIFE", TList::Class(),AliAnalysisManager::kOutputContainer,qaNamePOIFE);
- mgr->ConnectOutput(taskFE,1,coutputQA1FE);
- mgr->ConnectOutput(taskFE,2,coutputQA2FE);
+ mgr->ConnectOutput(taskFE,2,coutputQA1FE);
+ mgr->ConnectOutput(taskFE,3,coutputQA2FE);
}
// Create the output containers for the data produced by the analysis tasks
AliAnalysisDataContainer *coutputSP = mgr->CreateContainer("cobjSP", TList::Class(),AliAnalysisManager::kOutputContainer,outputSP);
mgr->ConnectInput(taskSP,0,coutputFE);
- mgr->ConnectOutput(taskSP,0,coutputSP);
+ mgr->ConnectOutput(taskSP,1,coutputSP);
+ if (WEIGHTS[0]) {
+ mgr->ConnectInput(taskSP,1,cinputWeights);
+ cinputWeights->SetData(weightsList);
+ }
}
if(LYZ1SUM) {
TString outputLYZ1SUM = AliAnalysisManager::GetCommonFileName();
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