AliAnalysisTaskStrangenessVsMultiplicityMC *AddTaskStrangenessVsMultiplicityMC( Bool_t lSaveV0 = kFALSE, Bool_t lSaveCascade = kTRUE, const TString lMasterJobSessionFlag = "")
{
// Creates, configures and attaches to the train a cascades check task.
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskStrangenessVsMultiplicity", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskStrangenessVsMultiplicity", "This task requires an input event handler");
return NULL;
}
TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
// Create and configure the task
AliAnalysisTaskStrangenessVsMultiplicityMC *taskAuxiliary = new AliAnalysisTaskStrangenessVsMultiplicityMC("taskAuxiliary");
mgr->AddTask(taskAuxiliary);
TString outputFileName = AliAnalysisManager::GetCommonFileName();
outputFileName += ":PWGLF_StrVsMult";
if (mgr->GetMCtruthEventHandler()) outputFileName += "_MC";
Printf("Set OutputFileName : \n %s\n", outputFileName.Data() );
AliAnalysisDataContainer *coutputList = mgr->CreateContainer("cList",
TList::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName );
AliAnalysisDataContainer *coutputTree = mgr->CreateContainer("cTreeEvent",
TTree::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName );
AliAnalysisDataContainer *coutputTreeV0 = mgr->CreateContainer("cTreeV0",
TTree::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName );
AliAnalysisDataContainer *coutputTreeCascade = mgr->CreateContainer("cTreeCascade",
TTree::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName );
//This one you should merge in file-resident ways...
coutputTree->SetSpecialOutput();
coutputTreeV0->SetSpecialOutput();
coutputTreeCascade->SetSpecialOutput();
//Recommendation: Tree as a single output slot
mgr->ConnectInput (taskAuxiliary, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(taskAuxiliary, 1, coutputList);
mgr->ConnectOutput(taskAuxiliary, 2, coutputTree);
mgr->ConnectOutput(taskAuxiliary, 3, coutputTreeV0);
mgr->ConnectOutput(taskAuxiliary, 4, coutputTreeCascade);
return taskAuxiliary;
}
AliAnalysisTaskEMCALTriggerQA * AddTaskEMCALTriggerQA(Bool_t kSimulation = kFALSE, TString outputFile = "")
{
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr)
{
::Error("AddTaskEMCALTriggerQA", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler())
{
::Error("AddTaskEMCALTriggerQA", "This task requires an input event handler");
return NULL;
}
TString taskName = "QAEMCALTrigger";
AliAnalysisTaskEMCALTriggerQA * qatrigger = new AliAnalysisTaskEMCALTriggerQA(taskName);
// Configuration
Bool_t kUseKinematics = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
if(kUseKinematics) kSimulation = kTRUE;
if(kSimulation) qatrigger->SwitchOnMCData();
else qatrigger->SwitchOffMCData();
TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
if(inputDataType.Contains("AOD")) qatrigger->SwitchOffV0SignalHistograms();
else qatrigger->SwitchOnV0SignalHistograms();
// Define the input/output containers
qatrigger->GetRecoUtils()->SwitchOnBadChannelsRemoval ();
AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
if(outputFile.Length()==0) outputFile = AliAnalysisManager::GetCommonFileName();
printf("*** Task Name %s; Output file name: %s ***\n",taskName.Data(),outputFile.Data());
AliAnalysisDataContainer *coutput = mgr->CreateContainer(Form("%s",taskName.Data()),
TList::Class(), AliAnalysisManager::kOutputContainer,
Form("%s",outputFile.Data()));
mgr->AddTask(qatrigger);
mgr->ConnectInput (qatrigger, 0, cinput1);
mgr->ConnectOutput (qatrigger, 1, coutput);
return qatrigger;
}
AliAnalysisTaskUpcEtaC *AddTaskUpcEtaC(Bool_t runTree = kTRUE,Bool_t runHist = kTRUE,Bool_t runSyst = kFALSE,Int_t tracking = 0){
//--- get the current analysis manager ---//
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
Error("AddTask_UpcEtaC", "No analysis manager found.");
return 0;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler()) {
Error("AddTask_UpcEtaC", "This task requires an input event handler");
return 0;
}
TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
Bool_t isMC;
if(mgr->GetMCtruthEventHandler()) isMC = kTRUE;
// Create tasks
AliAnalysisTaskUpcEtaC *task = new AliAnalysisTaskUpcEtaC(inputDataType.Data());
task->SetRunTree(runTree);
task->SetRunHist(runHist);
task->SetIsMC(isMC);
task->SetRunSyst(runSyst);
task->SetTracking(tracking);
mgr->AddTask(task);
// Create containers for input/output
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput = mgr->CreateContainer("EtaCK0sChannelTree", TTree::Class(), AliAnalysisManager::kOutputContainer,Form("%s:EtaCUpc", AliAnalysisManager::GetCommonFileName()));
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("EtaCTree", TTree::Class(), AliAnalysisManager::kOutputContainer, Form("%s:EtaCUpc", AliAnalysisManager::GetCommonFileName()));
AliAnalysisDataContainer *coutput3 = mgr->CreateContainer("ListTrig", TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:EtaCUpc", AliAnalysisManager::GetCommonFileName()));
AliAnalysisDataContainer *coutput4 = mgr->CreateContainer("ListHist", TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:EtaCUpc", AliAnalysisManager::GetCommonFileName()));
AliAnalysisDataContainer *coutput5 = mgr->CreateContainer("ListHistKstar", TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:EtaCUpc", AliAnalysisManager::GetCommonFileName()));
AliAnalysisDataContainer *coutput6 = mgr->CreateContainer("ListHist2Rho4Pion", TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:EtaCUpc", AliAnalysisManager::GetCommonFileName()));
AliAnalysisDataContainer *coutput7 = mgr->CreateContainer("ListHistK0s3PiPi4K", TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:EtaCUpc", AliAnalysisManager::GetCommonFileName()));
AliAnalysisDataContainer *coutput8 = mgr->CreateContainer("ListHistZDC", TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:EtaCUpc", AliAnalysisManager::GetCommonFileName()));
// Connect input/output
mgr->ConnectInput(task, 0, cinput);
mgr->ConnectOutput(task, 1, coutput);
mgr->ConnectOutput(task, 2, coutput2);
mgr->ConnectOutput(task, 3, coutput3);
mgr->ConnectOutput(task, 4, coutput4);
mgr->ConnectOutput(task, 5, coutput5);
mgr->ConnectOutput(task, 6, coutput6);
mgr->ConnectOutput(task, 7, coutput7);
mgr->ConnectOutput(task, 8, coutput8);
return task;
}
AliMultSelectionTask *AddTaskMultSelection( Bool_t lCalibration = kFALSE, TString lExtraOptions = "", Int_t lNDebugEstimators = 1, const TString lMasterJobSessionFlag = "")
{
// Creates, configures and attaches to the train a Multiplicity Selection Task
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskMultSelection", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskMultSelection", "This task requires an input event handler");
return NULL;
}
TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
// Create and configure the task
//Special options interpreting: will be taken care of by the task
// A - Add Extra AliCentrality V0M branch for cross-checks
// A - Add Extra AliPPVsMultUtils V0M branch for cross-checks
AliMultSelectionTask *taskMultSelection = new AliMultSelectionTask("taskMultSelection", lExtraOptions.Data(), lCalibration, lNDebugEstimators);
mgr->AddTask(taskMultSelection);
TString outputFileName = AliAnalysisManager::GetCommonFileName();
outputFileName += ":MultSelection";
if (mgr->GetMCtruthEventHandler()) outputFileName += "_MC";
Printf("Set OutputFileName : \n %s\n", outputFileName.Data() );
AliAnalysisDataContainer *coutputList = mgr->CreateContainer("cListMultSelection",
TList::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName );
//Recommendation: Tree as a single output slot
mgr->ConnectInput (taskMultSelection, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(taskMultSelection, 1, coutputList);
if ( lCalibration ) {
AliAnalysisDataContainer *coutputTree = mgr->CreateContainer("cCalibrationTree",
TTree::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName );
//This one you should merge in file-resident ways...
coutputTree->SetSpecialOutput();
mgr->ConnectOutput(taskMultSelection, 2, coutputTree);
}
return taskMultSelection;
}
AliAnalysisTaskJetMassResponseDet* AddTaskJetMassResponseDet(const char * njetsPart,
const char * njetsDet,
const Double_t R,
const char *type,
Int_t pSel,
TString kEmcalTriggers = "",
TString tag = "") {
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr)
{
Error("AddTaskEmcalJetMass","No analysis manager found.");
return 0;
}
Bool_t ismc=kFALSE;
ismc = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler())
{
::Error("AddTaskEmcalJetMass", "This task requires an input event handler");
return NULL;
}
TString wagonName = Form("JetMassResponseDet_%s%s",njetsDet,tag.Data());
TString strType(type);
//Configure jet mass detector response task
AliAnalysisTaskJetMassResponseDet *task = new AliAnalysisTaskJetMassResponseDet(wagonName.Data());
task->SetNCentBins(1);
//task->SetVzRange(-10.,10.);
task->SetJetContainerPart(0);
task->SetJetContainerDet(1);
AliJetContainer *jetContPart = task->AddJetContainer(njetsPart,strType,R);
if(jetContPart) {
// jetContPart->SetPercAreaCut(0.6);
}
AliJetContainer *jetContDet = task->AddJetContainer(njetsDet,strType,R);
if(jetContDet) {
jetContDet->SetPercAreaCut(0.6);
}
task->SetCaloTriggerPatchInfoName(kEmcalTriggers.Data());
task->SelectCollisionCandidates(pSel);
task->SetUseAliAnaUtils(kFALSE);
mgr->AddTask(task);
//Connnect input
mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer() );
//Connect output
TString contName(wagonName);
TString outputfile = Form("%s",AliAnalysisManager::GetCommonFileName());
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contName.Data(), TList::Class(),AliAnalysisManager::kOutputContainer,outputfile);
mgr->ConnectOutput(task,1,coutput1);
return task;
}
///
/// Main method calling all the configuration
/// It creates a CaloTrackCorrelations task for calorimeters performance studies,
/// configures it and adds it to the analysis manager.
///
/// The options that can be passed to the macro are:
/// \param suffix : A string with the type of trigger (default: MB, EMC)
/// \param simulation : A bool identifying the data as simulation
/// \param outputFile : A string to change the name of the histograms output file, default is AnalysisResults.root
/// \param year: The year the data was taken, used to configure some histograms
/// \param printSettings : A bool to enable the print of the settings per task
/// \param calibrate: if OADB was updated with calibration parameters not used in reconstruction, apply them here.
///
AliAnalysisTaskCaloTrackCorrelation *AddTaskCalorimeterQA(const char *suffix="default",
Bool_t simulation = kFALSE,
TString outputFile = "",
Int_t year = 2015,
Bool_t printSettings = kFALSE,
Bool_t calibrate = kTRUE)
{
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskCalorimeterQA", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskCalorimeter", "This task requires an input event handler");
return NULL;
}
TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
Bool_t kUseKinematics = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
TString ssuffix = suffix;
if(kUseKinematics || simulation)
{
simulation = kTRUE;
printf("AddTaskCalorimeterQA - CAREFUL : Triggered events not checked in simulation!! \n");
if(!ssuffix.Contains("default")) return NULL;
}
// Configure analysis
//===========================================================================
//Reader
//For this particular analysis few things done by the reader.
//Nothing else needs to be set.
AliCaloTrackReader * reader = 0x0;
if (inputDataType.Contains("AOD")) reader = new AliCaloTrackAODReader();
else if(inputDataType.Contains("ESD")) reader = new AliCaloTrackESDReader();
//reader->SetDebug(10);//10 for lots of messages
reader->SwitchOnEMCALCells();
reader->SwitchOnEMCAL();
reader->SwitchOnPHOSCells(); // For correlation plots
reader->SwitchOnPHOS(); // For correlation plots
reader->SetEMCALPtMin(0.);
reader->SwitchOnCTS();
reader->SetCTSPtMin (0.);
reader->SetZvertexCut(10.);
reader->SetDeltaAODFileName(""); //Do not create deltaAOD file, this analysis do not create branches.
reader->SwitchOffWriteDeltaAOD() ;
if(!ssuffix.Contains("default"))
{
reader->SwitchOnTriggerPatchMatching();
reader->SwitchOffBadTriggerEventsRemoval();
reader->SetTriggerPatchTimeWindow(8,9);
//reader->SetEventTriggerL0Threshold(2.);
}
if(!simulation) reader->AnalyzeOnlyPhysicsEvents(); // in case physics selection was not on
if(calibrate && !simulation) reader->SwitchOnClusterRecalculation();
else reader->SwitchOffClusterRecalculation();
if(printSettings) reader->Print("");
// *** Calorimeters Utils ***
AliCalorimeterUtils *cu = new AliCalorimeterUtils;
// Remove clusters close to borders, at least max energy cell is 1 cell away
cu->SetNumberOfCellsFromEMCALBorder(1);
if (year == 2010) cu->SetNumberOfSuperModulesUsed(4); //EMCAL first year
else if (year < 2014) cu->SetNumberOfSuperModulesUsed(10);
else cu->SetNumberOfSuperModulesUsed(20);
cu->SwitchOffRecalibration(); // Check the reader if it is taken into account during filtering
cu->SwitchOffRunDepCorrection();
cu->SwitchOnCorrectClusterLinearity();
Bool_t bExotic = kTRUE;
Bool_t bNonLin = kTRUE;
Bool_t bBadMap = kTRUE;
Bool_t bEnCalib = kFALSE;
Bool_t bTiCalib = kFALSE;
if(calibrate && !simulation)
{
cu->SwitchOnRecalibration(); // Check the reader if it is taken into account during filtering
cu->SwitchOffRunDepCorrection();
cu->SwitchOnRecalculateClusterPosition() ;
bEnCalib = kTRUE;
bTiCalib = kTRUE;
}
AliEMCALRecoUtils* recou = cu->GetEMCALRecoUtils();
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/EMCAL/macros/ConfigureEMCALRecoUtils.C");
TString recouStr = Form("(reinterpret_cast<AliEMCALRecoUtils*>(%p))", recou);
gInterpreter->ProcessLine(Form("ConfigureEMCALRecoUtils(%s, %d, %d, %d, %d, %d, %d)", recouStr.Data(),
(Int_t)simulation,
(Int_t)bExotic,
(Int_t)bNonLin,
(Int_t)bEnCalib,
(Int_t)bBadMap,
(Int_t)bTiCalib));
if(bBadMap)
cu->SwitchOnBadChannelsRemoval();
cu->SetDebug(-1);
if(printSettings) cu->Print("");
// ##### Analysis algorithm settings ####
AliAnaCalorimeterQA *emcalQA = new AliAnaCalorimeterQA();
//emcalQA->SetDebug(10); //10 for lots of messages
TString calorimeter = "EMCAL";
emcalQA->SetCalorimeter(calorimeter);
if(simulation)
{
// Access MC stack and fill more histograms
emcalQA->SwitchOnDataMC() ;
emcalQA->SwitchOffStudyBadClusters();
emcalQA->SwitchOffFillAllCellTimeHisto();
}
else
{
emcalQA->SwitchOffDataMC() ;
emcalQA->SwitchOffStudyBadClusters();
emcalQA->SwitchOnFillAllCellTimeHisto();
}
emcalQA->AddToHistogramsName("EMCAL_"); //Begining of histograms name
emcalQA->SwitchOffFiducialCut();
emcalQA->SwitchOnCorrelation();
emcalQA->SwitchOffFillAllTH3Histogram();
emcalQA->SwitchOffFillAllPositionHistogram();
emcalQA->SwitchOffFillAllPositionHistogram2();
//Set Histrograms bins and ranges
emcalQA->GetHistogramRanges()->SetHistoPtRangeAndNBins(0, 50, 100) ;
emcalQA->GetHistogramRanges()->SetHistoFinePtRangeAndNBins(0, 10, 200) ; // bining for fhAmpId
emcalQA->GetHistogramRanges()->SetHistoEtaRangeAndNBins(-0.70, 0.70, 140) ;
if ( year==2010 )
{
emcalQA->GetHistogramRanges()->SetHistoPhiRangeAndNBins(80*TMath::DegToRad(), 120*TMath::DegToRad(), 48) ;
emcalQA->GetHistogramRanges()->SetHistoXRangeAndNBins(-230,90,120);
emcalQA->GetHistogramRanges()->SetHistoYRangeAndNBins(370,450,40);
}
else if ( year < 2014 )
{
emcalQA->GetHistogramRanges()->SetHistoPhiRangeAndNBins(80*TMath::DegToRad(), 180*TMath::DegToRad(), 120) ;
emcalQA->GetHistogramRanges()->SetHistoXRangeAndNBins(-460,90,200);
emcalQA->GetHistogramRanges()->SetHistoYRangeAndNBins(100,450,100);
}
else // Run2
{
emcalQA->GetHistogramRanges()->SetHistoPhiRangeAndNBins(80*TMath::DegToRad(), 327*TMath::DegToRad(), 250) ;
emcalQA->GetHistogramRanges()->SetHistoXRangeAndNBins(-460,460,230);
emcalQA->GetHistogramRanges()->SetHistoYRangeAndNBins(-450,450,225);
}
emcalQA->GetHistogramRanges()->SetHistoMassRangeAndNBins(0., 0.65, 325) ;
emcalQA->GetHistogramRanges()->SetHistoAsymmetryRangeAndNBins(0., 1. , 10 );
emcalQA->GetHistogramRanges()->SetHistoPOverERangeAndNBins(0,2.,50);
emcalQA->GetHistogramRanges()->SetHistodEdxRangeAndNBins(0.,200.,100);
emcalQA->GetHistogramRanges()->SetHistodRRangeAndNBins(0.,0.10,50);
//emcalQA->GetHistogramRanges()->SetHistoTimeRangeAndNBins( 400,900,250);
//emcalQA->GetHistogramRanges()->SetHistoTimeRangeAndNBins(-275,275,250);
emcalQA->GetHistogramRanges()->SetHistoTimeRangeAndNBins(-275,975,250);
emcalQA->GetHistogramRanges()->SetHistoRatioRangeAndNBins(0.,2.,100);
emcalQA->GetHistogramRanges()->SetHistoVertexDistRangeAndNBins(0.,500.,500);
emcalQA->GetHistogramRanges()->SetHistoNClusterCellRangeAndNBins(0,50,50);
emcalQA->GetHistogramRanges()->SetHistoZRangeAndNBins(-350,350,175);
emcalQA->GetHistogramRanges()->SetHistoRRangeAndNBins(430,460,30);
emcalQA->GetHistogramRanges()->SetHistoV0SignalRangeAndNBins(0,5000,100);
emcalQA->GetHistogramRanges()->SetHistoV0MultiplicityRangeAndNBins(0,5000,100);
emcalQA->GetHistogramRanges()->SetHistoTrackMultiplicityRangeAndNBins(0,2500,100);
emcalQA->GetHistogramRanges()->SetHistoShowerShapeRangeAndNBins(0, 3, 120);
emcalQA->GetHistogramRanges()->SetHistoDiffTimeRangeAndNBins(-300, 300, 120);
emcalQA->GetHistogramRanges()->SetHistoTrackResidualEtaRangeAndNBins(-0.075,0.075,50);
emcalQA->GetHistogramRanges()->SetHistoTrackResidualPhiRangeAndNBins(-0.075,0.075,50);
if(printSettings) emcalQA->Print("");
// #### Configure Maker ####
AliAnaCaloTrackCorrMaker * maker = new AliAnaCaloTrackCorrMaker();
if(ssuffix.Contains("default")) maker->SwitchOffDataControlHistograms();
else maker->SwitchOnDataControlHistograms();
maker->SetReader(reader);//pointer to reader
maker->SetCaloUtils(cu); //pointer to calorimeter utils
maker->AddAnalysis(emcalQA,0);
maker->SetAnaDebug(-1) ; // 0 to at least print the event number
maker->SwitchOnHistogramsMaker() ;
maker->SwitchOffAODsMaker() ;
if(simulation)
{
// Calculate the cross section weights, apply them to all histograms
// and fill xsec and trial histo. Sumw2 must be activated.
//maker->GetReader()->GetWeightUtils()->SwitchOnMCCrossSectionCalculation();
//maker->SwitchOnSumw2Histograms();
// For recent productions where the cross sections and trials are not stored in separate file
//maker->GetReader()->GetWeightUtils()->SwitchOnMCCrossSectionFromEventHeader() ;
// Just fill cross section and trials histograms.
maker->GetReader()->GetWeightUtils()->SwitchOnMCCrossSectionHistoFill();
// Add control histogram with pT hard to control aplication of weights
maker->SwitchOnPtHardHistogram();
}
if(printSettings) maker->Print("");
printf("======================== \n");
printf("AddTaskCalorimeterQA() - End Configuration \n");
printf("======================== \n");
// Create task
//===========================================================================
AliAnalysisTaskCaloTrackCorrelation * task = new AliAnalysisTaskCaloTrackCorrelation (Form("CalorimeterPerformance_%s",suffix));
//task->SetConfigFileName(""); //Don't configure the analysis via configuration file.
//task->SetDebugLevel(-1);
task->SetAnalysisMaker(maker);
task->SetBranches("ESD:AliESDRun.,AliESDHeader"); //just a trick to get Constantin's analysis to work
mgr->AddTask(task);
//Create containers
// AliAnalysisDataContainer *cout_pc = mgr->CreateContainer("Calo.Performance",TList::Class(),
// AliAnalysisManager::kOutputContainer, "Calo.Performance.root");
TString cname;
if(outputFile.Length()==0)outputFile = AliAnalysisManager::GetCommonFileName();
cname = Form("CaloQA_%s", suffix);
AliAnalysisDataContainer *cout_pc = mgr->CreateContainer(cname, TList::Class(),
AliAnalysisManager::kOutputContainer,
Form("%s:%s",outputFile.Data(),cname.Data()));
// cname = Form("CaloQACuts_%s", suffix);
// AliAnalysisDataContainer *cout_cuts = mgr->CreateContainer(cname, TList::Class(),
// AliAnalysisManager::kParamContainer,
// Form("%s:%s",outputFile.Data(),cname.Data()));
//Form("%s:PartCorrCuts",outputfile.Data()));
// Create ONLY the output containers for the data produced by the task.
// Get and connect other common input/output containers via the manager as below
//==============================================================================
mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput (task, 1, cout_pc);
// mgr->ConnectOutput (task, 2, cout_cuts);
return task;
}
AliAnalysisTask *AddTaskEMCALCorrectionForEHTask(UInt_t kPhysSel = AliVEvent::kAny)
{
//get the current analysis manager
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
Error("AddTaskHFEElecHadronCorrlPbPb", "No analysis manager found.");
return 0;
}
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskHFEElecHadronCorrlPbPb", "This task requires an input event handler");
return NULL;
}
TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
/* if (type=="AOD"){
::Error("AddTaskHFEElecHadronCorrlPbPb", "The tasks exits because AODs are in input");
return NULL;
}
*/
Bool_t MCthere=kTRUE;
AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler*>(mgr->GetMCtruthEventHandler());
if(!mcH){
MCthere=kFALSE;
}
gROOT->LoadMacro("$ALICE_PHYSICS/PWGPP/PilotTrain/AddTaskCDBconnect.C");
gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEMCALTender.C");
gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskClusterizerFast.C");
gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalClusterMaker.C");
gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalAodTrackFilter.C");
gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalClusTrackMatcher.C");
TString sTracksName("AODFilterTracks");
TString sClusName("EmcCaloClusters");
// Setup task
AliTaskCDBconnect *taskCDB = AddTaskCDBconnect();
taskCDB->SetFallBackToRaw(kTRUE);
// Tender Supplies
const char *cPass = 0;
Bool_t bDistBC = kFALSE; //switch for recalculation cluster position from bad channel
Bool_t bRecalibClus = kFALSE;
Bool_t bRecalcClusPos = kFALSE;
Bool_t bNonLinearCorr = kFALSE;
Bool_t bRemExoticCell = kFALSE;
Bool_t bRemExoticClus = kFALSE;
Bool_t bFidRegion = kFALSE;
Bool_t bCalibEnergy = kTRUE;
Bool_t bCalibTime = kTRUE;
Bool_t bRemBC = kTRUE;
UInt_t iNonLinFunct = AliEMCALRecoUtils::kNoCorrection;
Bool_t bReclusterize = kFALSE;
Float_t fSeedThresh = 0.1; // 100 MeV
Float_t fCellThresh = 0.05; // 50 MeV
UInt_t iClusterizer = AliEMCALRecParam::kClusterizerv2;
Bool_t bTrackMatch = kFALSE;
Bool_t bUpdateCellOnly = kTRUE;
Float_t fEMCtimeMin = -50e-6;
Float_t fEMCtimeMax = 50e-6;
Float_t fEMCtimeCut = 1e6;
Bool_t remExoticCell = kFALSE;
AliAnalysisTaskSE *pTenderTask = AddTaskEMCALTender(bDistBC, bRecalibClus, bRecalcClusPos, bNonLinearCorr, bRemExoticCell, bRemExoticClus,
bFidRegion, bCalibEnergy, bCalibTime, bRemBC, iNonLinFunct, bReclusterize, fSeedThresh,
fCellThresh, iClusterizer, bTrackMatch, bUpdateCellOnly, fEMCtimeMin, fEMCtimeMax, fEMCtimeCut, cPass);
pTenderTask->SelectCollisionCandidates(kPhysSel);
//Clusterizer task
AliAnalysisTaskEMCALClusterizeFast *pClusterizerTask = AddTaskClusterizerFast("ClusterizerFast", "", "", iClusterizer,
fCellThresh, fSeedThresh, fEMCtimeMin, fEMCtimeMax, fEMCtimeCut,
remExoticCell, bDistBC, AliAnalysisTaskEMCALClusterizeFast::kFEEData);
pClusterizerTask->SelectCollisionCandidates(kPhysSel);
//Cluster maker task
UInt_t nonLinFunct = AliEMCALRecoUtils::kBeamTestCorrected;
Bool_t remExoticClus = kTRUE;
AliEmcalClusterMaker *pClusterMakerTask = AddTaskEmcalClusterMaker(nonLinFunct, remExoticClus, "usedefault", sClusName, 0., kTRUE);
pClusterMakerTask->GetClusterContainer(0)->SetClusPtCut(0.);
pClusterMakerTask->GetClusterContainer(0)->SetClusECut(0.);
pClusterMakerTask->SelectCollisionCandidates(kPhysSel);
//tracks maker for AOD
char* periodstr = "16:1:includeNoITS=kTRUE doProp=kTRUE doAttemptProp=kFALSE isMC=kFALSE";
TString period(periodstr);
Bool_t doAODTrackProp = kTRUE;
Double_t trackeff = 1.0;
Double_t edist = 440;
AliEmcalAodTrackFilterTask *pHybTask = AddTaskEmcalAodTrackFilter(sTracksName,"tracks",period);
if (doAODTrackProp) {
pHybTask->SetDist(edist);
pHybTask->SetAttemptPropMatch(kTRUE);
}
pHybTask->SelectCollisionCandidates(AliVEvent::kAny);
pHybTask->SetTrackEfficiency(trackeff);
// Cluster-track matcher task
Double_t maxMatchR = 0.1;
Bool_t attachEmcalPart = kFALSE;
Bool_t updateClusters = kTRUE;
Bool_t updateTracks = kTRUE;
Bool_t doHistos = kTRUE;
Int_t nCentBins = 4;
AliEmcalClusTrackMatcherTask *pMatcherTask = AddTaskEmcalClusTrackMatcher(sTracksName, sClusName, maxMatchR, attachEmcalPart, updateClusters, updateTracks, doHistos);
pMatcherTask->SelectCollisionCandidates(kPhysSel);
pMatcherTask->SetNCentBins(nCentBins);
pMatcherTask->GetClusterContainer(0)->SetClusECut(0.0);
pMatcherTask->GetClusterContainer(0)->SetClusPtCut(0.);
pMatcherTask->GetParticleContainer(0)->SetParticlePtCut(0.0);
return pMatcherTask;
}
AliAnalysisTaskEMCALClusterizeFast* AddTaskClusterizerFW(
const char* trigType = "L0", // Trigger type: it can be "L0" (4x4, with 2x2 sliding inside SM),
//"L1GAMMA" (4x4, with 2x2 sliding through SMs), "L1JET" (32x32 with 4x4 sliding through SMs)
const Bool_t fOR = kFALSE,
const TString & geomName = "EMCAL_COMPLETEV1",
Double_t minE = -1
)
{
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskClusterizerFW", "No analysis manager found.");
return 0;
}
Bool_t ismc=kFALSE;
ismc = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
if (ismc)
::Warning("AddTaskClusterizerFW", "Task was Never tested on MC data");
TString name("ClusterizerFW");
TString nameout("Clusters");
Int_t n, s;
Float_t minE, minT, maxT;
Bool_t slidingTRU;
Bool_t cutL0time;
UInt_t inputCellType = AliAnalysisTaskEMCALClusterizeFast::kFEEData;
name += trigType;
nameout += trigType;
if (!strcmp(trigType, "L0")) {
n = 4;
s = 2;
slidingTRU = 0;
if (fOR) inputCellType = AliAnalysisTaskEMCALClusterizeFast::kL0FastORsTC;
} else if (!strcmp(trigType, "L1GAMMA")) {
n = 4;
s = 2;
slidingTRU = 1;
if (fOR) inputCellType = AliAnalysisTaskEMCALClusterizeFast::kL1FastORs;
} else if (!strcmp(trigType, "L1JET")) {
n = 32;
s = 4;
slidingTRU = 1;
if (fOR) inputCellType = AliAnalysisTaskEMCALClusterizeFast::kL1FastORs;
} else {
printf("trigType not valid, returning...");
return 0;
}
if (fOR) {
name += "FOR";
nameout += "FOR";
if (minE < 0) minE = 3;
minT = -20;
maxT = 20;
} else {
name += "FEE";
nameout += "FEE";
if (minE < 0) minE = .045;
minT = -1.;
maxT = +1.;
}
AliAnalysisTaskEMCALClusterizeFast *task = new AliAnalysisTaskEMCALClusterizeFast(name);
AliEMCALRecParam *recparam = task->GetRecParam();
recparam->SetClusterizerFlag(AliEMCALRecParam::kClusterizerFW);
recparam->SetMinECut(minE);
recparam->SetTimeMax(maxT);
recparam->SetTimeMin(minT);
task->SetGeometryName(geomName);
task->SetAttachClusters(kTRUE);
task->SetOverwrite(kFALSE);
task->SetNewClusterArrayName(nameout);
task->SetnPhi(n);
task->SetnEta(n);
task->SetShiftPhi(s);
task->SetShiftEta(s);
task->SetTRUShift(!slidingTRU);
task->SetInputCellType(inputCellType);
task->SetLoadPed(kFALSE);
task->SetLoadCalib(kFALSE);
task->SetRecalibrateCellsOnly(kFALSE);
mgr->AddTask(task);
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
cout << " *** " << name << " configured *** " << endl;
return task;
}
AliAnalysisTaskKinkResonance *AddTaskKinkResonancePhiMC(Short_t lCollidingSystems=0 /*0 = pp, 1 = AA*/)
{
// Creates, configures and attaches to the train a kink resonance task.
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskKinkResonancePhiMC", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskKinkResonancePhiMC", "This task requires an input event handler");
return NULL;
}
TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
if (type != "ESD") {
::Error("AddTaskKinkResonancePhiMC", "This task needs an ESD input handler");
return NULL;
}
if (!mgr->GetMCtruthEventHandler()) {
::Error("AddTaskKinkResonancePhiMC", "This task needs an MC handler");
return NULL;
}
// Setup the analysis object
AliResonanceKink *kinkResonanceObjectPMC=new AliResonanceKink();
kinkResonanceObjectPMC->InitOutputHistograms(70,0.99,1.088, 36, -0.9, 0.9, 100, 0.0, 10.0);
kinkResonanceObjectPMC->SetPDGCodes(kKPlus, kKPlus, AliResonanceKink::kPhi);
kinkResonanceObjectPMC->SetAnalysisType("MC"); // "ESD" or "MC" or "DATA"
kinkResonanceObjectPMC->SetMaxNsigmaToVertex(4.0);
kinkResonanceObjectPMC->SetMaxDCAxy(3.0);
kinkResonanceObjectPMC->SetMaxDCAzaxis(3.0);
kinkResonanceObjectPMC->SetPtTrackCut(0.25);
kinkResonanceObjectPMC->SetMinTPCclusters(50);
kinkResonanceObjectPMC->SetMaxChi2PerTPCcluster(3.5);
kinkResonanceObjectPMC->SetMaxCov0(2.0);
kinkResonanceObjectPMC->SetMaxCov2(2.0);
kinkResonanceObjectPMC->SetMaxCov5(0.5);
kinkResonanceObjectPMC->SetMaxCov9(0.5);
kinkResonanceObjectPMC->SetMaxCov14(2.0);
kinkResonanceObjectPMC->SetMinKinkRadius(120.);
kinkResonanceObjectPMC->SetMaxKinkRadius(220.);
kinkResonanceObjectPMC->SetQtLimits(0.05, 0.5);
kinkResonanceObjectPMC->SetUpperAbsEtaCut(0.9);
// Create and configure the task
AliAnalysisTaskKinkResonance *taskresonancePhiMC = new AliAnalysisTaskKinkResonance("TaskResPhiMCKinkPID");
taskresonancePhiMC->SetAnalysisKinkObject(kinkResonanceObjectPMC);
mgr->AddTask(taskresonancePhiMC);
// Create ONLY the output containers for the data produced by the task.
// Get and connect other common input/output containers via the manager as below
//==============================================================================
TString outputFileName = AliAnalysisManager::GetCommonFileName();
outputFileName += ":PWG2KINKResonancePhiMC";
if (lCollidingSystems) outputFileName += "_AA";
else outputFileName += "_PP";
if (mgr->GetMCtruthEventHandler()) outputFileName += "_MC";
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("KinkResPhiMC",
TList::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName );
mgr->ConnectInput(taskresonancePhiMC, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(taskresonancePhiMC, 1, coutput1);
return taskresonancePhiMC;
}
/**
* Add a Forward MC correction generator task to train
*
*
* @return Added task
*
* @ingroup pwglf_forward_mc
*/
AliAnalysisTask*
AddTaskForwardMCCorr(Bool_t satellite=false,
UShort_t rflags=0,
UShort_t maxStrips=2)
{
// --- Load libraries ----------------------------------------------
gROOT->LoadClass("AliAODForwardMult", "libPWGLFforward2");
// --- Creating the manager and handlers ---------------------------
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr->GetMCtruthEventHandler()) {
Error("AddTaskCentralMCCorr",
"No MC input handler defined - cannot continue");
return 0;
}
// --- Add our task ------------------------------------------------
AliForwardMCCorrectionsTask* task =
new AliForwardMCCorrectionsTask("ForwardCorr");
task->GetTrackDensity().SetDebug(false);
task->SetSatellite(satellite);
AliFMDMCTrackDensity& dn =
static_cast<AliFMDMCTrackDensity&>(task->GetTrackDensity());
dn.SetMaxConsequtiveStrips(maxStrips); // was 3
// task->SetVertexAxis(40, -20., 20.);
if (rflags != 0) {
AliSimplePidWeights* w = new AliSimplePidWeights();
if (rflags & 0x4) {
// Realistic weights
// Based on measurements in Pb-Pb @ 2.76
//
// Ratio to pi+- Reference Value [%]
// -------------+---------------+----------
// p/pbar | PRC88,044910 | 4.57
// K+- | PRC88,044910 | 14.88
// K^0_S | PRL111,222301 | 7.51
// Lambda | PRL111,222301 | 1.77
// Xi^0 | - | -
//
// WA98 Xi-/Lambda ~ 0.15 ->
// Xi- / pi = Xi-/Lambda Lambda / pi = 0.14 * 1.77 = 0.25%
// WA98 Omega-/Xi- ~ 0.25
// Omega- / pi- = Omega-/Xi- Xi-/pi = 0.25 * 0.25 = 0.06%
w->AddPDGCode(321, 2.0,true); // kaons
w->AddPDGCode(310, 1.5,true); // K0s
w->AddPDGCode(3122,1.5,true); // Lambda
w->AddPDGCode(3212,1.5,true); // Sigma0
w->AddPDGCode(3322,6.0,true); // Xi0
}
else {
// Roberto's analysis of Pb-Pb @ 5.02TeV
//
// pi^+/-2 [ 211]: 0.9412
// K^+/- [ 321]: 1.4118
// p/pbar [2212]: 0.9412
// K^0_S [ 310]: 1.5223
// Lambda [3122]: 2.7500
// Sigma^0 [3212]: 2.7500
// Xi^0 [3322]: 3.2411
w->AddPDGCode(211, 0.9583*0.9822,true); // pions
w->AddPDGCode(321, 1.4374*0.9822,true); // kaons
w->AddPDGCode(2212,0.9583*0.9822,true); // protons
w->AddPDGCode(310, 1.0000*1.5223,true); // K0s
w->AddPDGCode(3122,1.0000*2.7500,true); // Lambda
w->AddPDGCode(3212,1.0000*2.7500,true); // Sigma0
w->AddPDGCode(3322,1.0000*3.2411,true); // Xi0
}
if (rflags & 0x1) task->GetTrackDensity().SetWeights(w);
if (rflags & 0x2) task->GetTrackDensity().SetTruthWeights(w);
}
// --- connect input/output ----------------------------------------
task->Connect(0, 0);
return task;
}
EmcalHJetMassAnalysis::AliAnalysisTaskEmcalHJetMass* AddTaskEmcalHJetMass(const char * njetsBase,
const Double_t R,
const char * nrhoBase,
const char * ntracks,
const char * nclusters,
const char * type,
Double_t ptMinH = 5.,
Double_t maxDPhi = 0.6,
Int_t pSel,
const char * CentEst = "V0M",
TString trigClass = "",
TString kEmcalTriggers = "",
TString nJetsUnsub = "",
TString tag = "") {
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr)
{
Error("AddTaskEmcalHJetMass","No analysis manager found.");
return 0;
}
Bool_t ismc=kFALSE;
ismc = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler())
{
::Error("AddTaskEmcalHJetMass", "This task requires an input event handler");
return NULL;
}
TString wagonName = Form("HJetMass_%s_TC%s%s",njetsBase,trigClass.Data(),tag.Data());
//Configure jet tagger task
EmcalHJetMassAnalysis::AliAnalysisTaskEmcalHJetMass *task = new EmcalHJetMassAnalysis::AliAnalysisTaskEmcalHJetMass(wagonName.Data());
task->SetNCentBins(4);
task->SetMaxDeltaPhi(maxDPhi);
AliParticleContainer *trackCont = task->AddParticleContainer(ntracks);
trackCont->SetParticlePtCut(ptMinH);
AliClusterContainer *clusterCont = task->AddClusterContainer(nclusters);
task->SetJetContainerBase(0);
TString strType(type);
AliJetContainer *jetContBase = task->AddJetContainer(njetsBase,strType,R);
if(jetContBase) {
jetContBase->SetRhoName(nrhoBase);
jetContBase->ConnectParticleContainer(trackCont);
jetContBase->ConnectClusterContainer(clusterCont);
jetContBase->SetPercAreaCut(0.6);
}
if(!nJetsUnsub.IsNull()) {
AliJetContainer *jetContUS = task->AddJetContainer(nJetsUnsub.Data(),strType,R);
if(jetContUS) {
jetContUS->SetRhoName(nrhoBase);
jetContUS->ConnectParticleContainer(trackCont);
jetContUS->ConnectClusterContainer(clusterCont);
jetContUS->SetPercAreaCut(0.6);
}
}
task->SetCaloTriggerPatchInfoName(kEmcalTriggers.Data());
task->SetCentralityEstimator(CentEst);
task->SelectCollisionCandidates(pSel);
task->SetUseAliAnaUtils(kFALSE);
mgr->AddTask(task);
//Connnect input
mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer() );
//Connect output
TString contName(wagonName);
TString outputfile = Form("%s",AliAnalysisManager::GetCommonFileName());
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contName.Data(), TList::Class(),AliAnalysisManager::kOutputContainer,outputfile);
mgr->ConnectOutput(task,1,coutput1);
return task;
}
//____________________________________________
AliPerformanceTask* AddTaskPerformanceTPCdEdxQA(Bool_t bUseMCInfo=kFALSE, Bool_t bUseESDfriend=kTRUE,
Bool_t highMult = kFALSE, const char *triggerClass=0,
Bool_t bUseHLT = kFALSE, Bool_t bUseTOF = kFALSE, Bool_t bTPCTrackingOnly = kFALSE,
Bool_t bDoEffTpcSec = kFALSE)
{
const TString taskName[] = {"TPC", "HLT"};
const TString taskName2[] = {"", "_Tracking"};
Int_t idx = 0, idx2 = 0;
if (bUseHLT) idx = 1;
if (bTPCTrackingOnly) idx2 = 1;
//
// Add AliPerformanceTask with TPC performance components
//
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if(!mgr) {
Error("AddTaskPerformanceTPCdEdxQA","AliAnalysisManager not set!");
return NULL;
}
TString type = mgr->GetInputEventHandler()->GetDataType();
if (!type.Contains("ESD")) {
Error("AddTaskPerformanceTPCdEdxQA", "ESD input handler needed!");
return NULL;
}
AliMCEventHandler *mcH = (AliMCEventHandler*)mgr->GetMCtruthEventHandler();
if (!mcH && bUseMCInfo) {
Error("AddTaskPerformanceTPCdEdxQA", "MC input handler needed!");
return NULL;
}
//
// Add HLT Event
//
if (bUseHLT) {
AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*>(mgr->GetInputEventHandler());
esdH->SetReadHLT();
}
//
// Create task
//
AliPerformanceTask *task = new AliPerformanceTask("PerformanceQA",Form("%s%s Performance",taskName[idx].Data(), taskName2[idx2].Data()));
if (!task) {
Error("AddTaskPerformanceTPCdEdxQA", "%s", Form("%s%s performance task cannot be created!",taskName[idx].Data(), taskName2[idx2].Data()));
return NULL;
}
task->SetUseMCInfo(bUseMCInfo);
task->SetUseESDfriend(bUseESDfriend);
// task->SetUseTerminate(kFALSE);
task->SetUseHLT(bUseHLT);
//
// Add task to analysis manager
//
mgr->AddTask(task);
//
// Create TPC-ESD track reconstruction cuts
// MB tracks
//
AliRecInfoCuts *pRecInfoCutsTPC = new AliRecInfoCuts("pRecInfoCutsTPC");
if(pRecInfoCutsTPC) {
pRecInfoCutsTPC->SetMaxDCAToVertexXY(3.0);
pRecInfoCutsTPC->SetMaxDCAToVertexZ(3.0);
pRecInfoCutsTPC->SetRequireSigmaToVertex(kFALSE);
pRecInfoCutsTPC->SetRequireTPCRefit(kFALSE);
pRecInfoCutsTPC->SetAcceptKinkDaughters(kFALSE);
pRecInfoCutsTPC->SetMinNClustersTPC(70);
pRecInfoCutsTPC->SetMaxChi2PerClusterTPC(4.);
pRecInfoCutsTPC->SetDCAToVertex2D(kTRUE);
pRecInfoCutsTPC->SetHistogramsOn(kFALSE);
} else {
Error("AddTaskPerformanceTPCdEdxQA", "AliRecInfoCutsTPC cannot be created!");
return NULL;
}
//
// Create TPC-MC track reconstruction cuts
//
AliMCInfoCuts *pMCInfoCuts = new AliMCInfoCuts("pMCInfoCuts");
if(pMCInfoCuts) {
pMCInfoCuts->SetMinTrackLength(70);
} else {
Error("AddTaskPerformanceTPCdEdxQA", "AliMCInfoCuts cannot be created!");
return NULL;
}
//
// Create performance objects for TPC and set cuts
//
enum { kTPC = 0, kTPCITS, kConstrained, kTPCInner, kTPCOuter, kTPCSec };
AliPerformanceTPC *pCompTPC0;
AliPerformanceMatch *pCompMatch1;
AliPerformanceMatch *pCompMatch2;
AliPerformanceDEdx *pCompDEdx3;
if (bTPCTrackingOnly == kFALSE) {
//
// TPC performance
//
pCompTPC0 = new AliPerformanceTPC("AliPerformanceTPC","AliPerformanceTPC",kTPC,kFALSE,-1,highMult);
if(!pCompTPC0) {
Error("AddTaskPerformanceTPCdEdxQA", "Cannot create AliPerformanceTPC");
}
pCompTPC0->SetAliRecInfoCuts(pRecInfoCutsTPC);
pCompTPC0->SetAliMCInfoCuts(pMCInfoCuts);
// pCompTPC0->SetUseTrackVertex(kFALSE);
pCompTPC0->SetUseTrackVertex(kTRUE);
pCompTPC0->SetUseHLT(bUseHLT);
pCompTPC0->SetUseTOFBunchCrossing(bUseTOF);
//
// TPC ITS match
//
pCompMatch1 = new AliPerformanceMatch("AliPerformanceMatchTPCITS","AliPerformanceMatchTPCITS",0,kFALSE);
if(!pCompMatch1) {
Error("AddTaskPerformanceTPCdEdxQA", "Cannot create AliPerformanceMatchTPCITS");
}
pCompMatch1->SetAliRecInfoCuts(pRecInfoCutsTPC);
pCompMatch1->SetAliMCInfoCuts(pMCInfoCuts);
pCompMatch1->SetUseTOFBunchCrossing(bUseTOF);
//
// ITS TPC match
//
pCompMatch2 = new AliPerformanceMatch("AliPerformanceMatchITSTPC","AliPerformanceMatchITSTPC",1,kFALSE);
if(!pCompMatch2) {
Error("AddTaskPerformanceTPCdEdxQA", "Cannot create AliPerformanceMatchITSTPC"); }
pCompMatch2->SetAliRecInfoCuts(pRecInfoCutsTPC);
pCompMatch2->SetAliMCInfoCuts(pMCInfoCuts);
pCompMatch2->SetUseTOFBunchCrossing(bUseTOF);
//
// dEdx
//
pCompDEdx3 = new AliPerformanceDEdx("AliPerformanceDEdxTPCInner","AliPerformanceDEdxTPCInner",kTPCInner,kFALSE);
if(!pCompDEdx3) {
Error("AddTaskPerformanceTPCdEdxQA", "Cannot create AliPerformanceDEdxTPCInner");
}
pCompDEdx3->SetAliRecInfoCuts(pRecInfoCutsTPC);
pCompDEdx3->SetAliMCInfoCuts(pMCInfoCuts);
//pCompDEdx3->SetUseTrackVertex(kFALSE);
pCompDEdx3->SetUseTrackVertex(kTRUE);
} //end bTPCTrackingOnly == kFALSE
//
// Resolution ------------------------------------------------------------------------------------
//
AliPerformanceRes *pCompRes4 = new AliPerformanceRes(bTPCTrackingOnly ? "AliPerformanceResTPC" : "AliPerformanceRes",
"AliPerformanceRes", bTPCTrackingOnly == kTRUE ? kTPCInner : kTPC,kFALSE);
if(!pCompRes4) {
Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceRes");
}
pCompRes4->SetAliRecInfoCuts(pRecInfoCutsTPC);
pCompRes4->SetAliMCInfoCuts(pMCInfoCuts);
pCompRes4->SetUseTrackVertex(bTPCTrackingOnly == kTRUE ? kFALSE : kTRUE);
//
// Efficiency ------------------------------------------------------------------------------------
//
AliPerformanceEff *pCompEff5 = new AliPerformanceEff(bTPCTrackingOnly ? "AliPerformanceEffTPC" : "AliPerformanceEff",
"AliPerformanceEff",kTPC,kFALSE);
if(!pCompEff5) {
Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceEff");
}
AliRecInfoCuts *pRecInfoCutsTPC2 = NULL;
if (bTPCTrackingOnly)
{
//For low pt tracks, HLT finds only short track segments.
//Hence, for the tpc-tracking only tracking-efficiency, we lower the minimum number of hits per reconstructed TPC track
pRecInfoCutsTPC2 = new AliRecInfoCuts(*pRecInfoCutsTPC);
pRecInfoCutsTPC2->SetMinNClustersTPC(20);
pCompEff5->SetAliRecInfoCuts(pRecInfoCutsTPC2);
}
else
{
pCompEff5->SetAliRecInfoCuts(pRecInfoCutsTPC);
}
pCompEff5->SetAliMCInfoCuts(pMCInfoCuts);
pCompEff5->SetUseTrackVertex(bTPCTrackingOnly == kTRUE ? kFALSE : kTRUE);
AliPerformanceEff *pCompEff5Sec;
if (bDoEffTpcSec)
{
pCompEff5Sec = new AliPerformanceEff(bTPCTrackingOnly ? "AliPerformanceEffSecTPC" : "AliPerformanceEffSec",
"AliPerformanceEffSec",kTPCSec,kFALSE);
if(!pCompEff5Sec) {
Error("AddTaskPerformanceTPC", "Cannot create AliPerformanceEff");
}
pCompEff5Sec->SetAliRecInfoCuts(bTPCTrackingOnly ? pRecInfoCutsTPC2 : pRecInfoCutsTPC);
pCompEff5Sec->SetAliMCInfoCuts(pMCInfoCuts);
pCompEff5Sec->SetUseTrackVertex(bTPCTrackingOnly == kTRUE ? kFALSE : kTRUE);
}
//
// TPC Constrain to vertex
//
AliPerformanceMatch *pCompConstrain6;
if (bTPCTrackingOnly == kFALSE) {
pCompConstrain6 = new AliPerformanceMatch("AliPerformanceMatchTPCConstrain","AliPerformanceMatchTPCConstrain",2,kFALSE);
if(!pCompConstrain6) {
Error("AddTaskPerformanceTPCdEdxQA", "Cannot create AliPerformanceMatchTPCConstrain"); }
pCompConstrain6->SetAliRecInfoCuts(pRecInfoCutsTPC);
pCompConstrain6->SetAliMCInfoCuts(pMCInfoCuts);
pCompConstrain6->SetUseTOFBunchCrossing(bUseTOF);
} //end bTPCTrackingOnly == kFALSE
//
// Add components to the performance task
//
if (bTPCTrackingOnly == kFALSE) {
if(!bUseMCInfo) {
pCompTPC0->SetTriggerClass(triggerClass);
pCompMatch1->SetTriggerClass(triggerClass);
pCompMatch2->SetTriggerClass(triggerClass);
pCompDEdx3->SetTriggerClass(triggerClass);
pCompConstrain6->SetTriggerClass(triggerClass);
}
task->AddPerformanceObject( pCompTPC0 );
task->AddPerformanceObject( pCompMatch1 );
task->AddPerformanceObject( pCompMatch2 );
task->AddPerformanceObject( pCompDEdx3 );
task->AddPerformanceObject( pCompConstrain6 );
} //end bTPCTrackingOnly == kFALSE
if(bUseMCInfo) {
task->AddPerformanceObject( pCompRes4 );
task->AddPerformanceObject( pCompEff5 );
if (bDoEffTpcSec) task->AddPerformanceObject( pCompEff5Sec );
}
//
// Create containers for input
//
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
//
// Create containers for output
//
AliAnalysisDataContainer *coutput = mgr->CreateContainer(Form("%s%sQA", taskName[idx].Data(), taskName2[idx2].Data()), TList::Class(),
AliAnalysisManager::kOutputContainer,
Form("%s:%s_%s", mgr->GetCommonFileName(), taskName[idx].Data(),task->GetName()));
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(Form("%s%sQASummary", taskName[idx].Data(), taskName2[idx2].Data()), TTree::Class(),
AliAnalysisManager::kParamContainer,
Form("trending.root:Summary%sQA", taskName[idx].Data()));
mgr->ConnectOutput(task, 1, coutput);
mgr->ConnectOutput(task, 0, coutput2);
return task;
}
AliAnalysisTaskParticleCorrelation *AddTaskPartCorr(TString inputDataType, TString calorimeter, Bool_t kPrintSettings = kFALSE,Bool_t kSimulation = kFALSE, Bool_t outputAOD=kFALSE, Bool_t oldAOD=kFALSE, Int_t debugLevel = 0)
{
// Creates a PartCorr task, configures it and adds it to the analysis manager.
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskPartCorr", "No analysis manager to connect to.");
return NULL;
}
Bool_t kUseKinematics = kFALSE;
if(kSimulation) {
kUseKinematics = (mgr->GetMCtruthEventHandler())?kTRUE:kFALSE;
if (!kUseKinematics && inputDataType == "AOD") kUseKinematics = kTRUE; //AOD primary should be available ...
}
cout<<"********* ACCESS KINE? "<<kUseKinematics<<endl;
// Configure analysis
//===========================================================================
// *** Reader ***
AliCaloTrackReader * reader =0x0 ;
if(inputDataType.Contains("AOD")) reader = new AliCaloTrackAODReader();
else if(inputDataType=="ESD") reader = new AliCaloTrackESDReader();
else if(inputDataType=="MC" && inputDataType == "ESD") reader = new AliCaloTrackMCReader();
reader->SetDebug(-1);//10 for lots of messages
reader->SwitchOnCTS();
reader->SwitchOffEMCAL();
reader->SwitchOffPHOS();
reader->SwitchOffEMCALCells();
reader->SwitchOffPHOSCells();
reader->SetDataType(2);
//Min particle pT
reader->SetEMCALPtMin(0.3);
reader->SetPHOSPtMin(0.3);
reader->SetCTSPtMin(0.1);
reader->SwitchOnWriteDeltaAOD() ;
// if(oldAOD) reader->SwitchOnOldAODs();
reader->SwitchOnWriteDeltaAOD();
if(kPrintSettings) reader->Print("");
// *** Calorimeters Utils ***
AliCalorimeterUtils *cu = new AliCalorimeterUtils;
//Recalibration
//cu->SwitchOnRecalibration();
//TFile * f = new TFile("RecalibrationFactors.root","read");
//cu->SetEMCALChannelRecalibrationFactors(0,(TH2F*)f->Get("EMCALRecalFactors_SM0"));
//cu->SetEMCALChannelRecalibrationFactors(1,(TH2F*)f->Get("EMCALRecalFactors_SM1"));
//cu->SetEMCALChannelRecalibrationFactors(2,(TH2F*)f->Get("EMCALRecalFactors_SM2"));
//cu->SetEMCALChannelRecalibrationFactors(3,(TH2F*)f->Get("EMCALRecalFactors_SM3"));
//f->Close();
cu->SetDebug(debugLevel);
if(kPrintSettings) cu->Print("");
// ##### Analysis algorithm settings ####
//==================================
// ### Isolation analysis ###
//=================================
//Photon
AliAnaParticleIsolation *anaisol = new AliAnaParticleIsolation();
anaisol->SetDebug(debugLevel);
anaisol->SetMinPt(0);
anaisol->SetInputAODName("ConversionGamma");
anaisol->SetAODObjArrayName("ConversionGamma");
anaisol->SetCalorimeter("CTS");
if(kUseKinematics) anaisol->SwitchOnDataMC() ;//Access MC stack and fill more histograms
else anaisol->SwitchOffDataMC() ;
anaisol->SwitchOffInvariantMass();
AliIsolationCut * ic = anaisol->GetIsolationCut();
ic->SetConeSize(0.4);
ic->SetPtThreshold(0.7);
ic->SetPtFraction(0.1);
ic->SetSumPtThreshold(1.0) ;
ic->SetParticleTypeInCone(AliIsolationCut::kOnlyCharged);
ic->SetICMethod(AliIsolationCut::kSumPtFracIC);
if(kPrintSettings) ic->Print("");
anaisol->SetHistoPtRangeAndNBins(0, 50, 500) ;
anaisol->AddToHistogramsName("AnaIsolPhoton_");
anaisol->SetOutputAODClassName("AliAODPWG4ParticleCorrelation");
anaisol->SwitchOnReIsolation();
anaisol->SwitchOffSeveralIsolation();
// anaisol->SetPtThresholds(0, 1.0);
// anaisol->SetPtThresholds(1, 2.0);
// anaisol->SetPtThresholds(2, 3.0);
// anaisol->SetPtThresholds(3, 4.0);
// anaisol->SetPtThresholds(4, 5.0);
// anaisol->SetPtFractions(0, 0.4);
// anaisol->SetPtFractions(1, 0.3);
// anaisol->SetPtFractions(2, 0.1);
// anaisol->SetPtFractions(3, 0.08);
// anaisol->SetPtFractions(4, 0.05);
// anaisol->SetNCones(5);
// anaisol->SetConeSizes(0, 0.50);
// anaisol->SetConeSizes(1, 0.60);
// anaisol->SetConeSizes(2, 0.70);
// anaisol->SetConeSizes(3, 0.80);
// anaisol->SetConeSizes(4, 0.90);
if(kPrintSettings) anaisol->Print("");
// //===========================
// //Correlation analysis
// //===========================
// // ### Correlation with Jet Finder AOD output
// AliAnaParticleJetFinderCorrelation *anacorrjet = new AliAnaParticleJetFinderCorrelation();
// anacorrjet->SetInputAODName("ConversionGamma");//,calorimeter.Data()));
// anacorrjet->SwitchOffFiducialCut();
// anacorrjet->SetDebug(debugLevel);
// anacorrjet->SetConeSize(1);
// anacorrjet->SelectIsolated(kTRUE); // do correlation with isolated photons
// anacorrjet->SetPtThresholdInCone(0.2);
// anacorrjet->SetDeltaPhiCutRange(0.5,5.5);//Mostly Open Cuts
// anacorrjet->SetRatioCutRange(0.01,3); //Mostly Open Cuts
// anacorrjet->UseJetRefTracks(kFALSE); //Not working now
// //Set Histograms bins and ranges
// anacorrjet->SetHistoPtRangeAndNBins(0, 50, 200) ;
// // ana->SetHistoPhiRangeAndNBins(0, TMath::TwoPi(), 100) ;
// // ana->SetHistoEtaRangeAndNBins(-0.7, 0.7, 100) ;
// if(kPrintSettings) anacorrjet->Print("");
// #### Configure Maker ####
AliAnaPartCorrMaker * maker = new AliAnaPartCorrMaker();
maker->SetReader(reader);//pointer to reader
maker->SetCaloUtils(cu); //pointer to calorimeter utils
Int_t n = 0;//Analysis number, order is important
maker->AddAnalysis(anaisol,n++);
//maker->AddAnalysis(anacorrjet, n++);
maker->SetAnaDebug(-1);
maker->SwitchOnHistogramsMaker() ;
if(kPrintSettings) maker->Print("");
printf("======================== \n");
printf(" End Configuration of PartCorr analysis with detector %s \n",calorimeter.Data());
printf("======================== \n");
// Create task
//===========================================================================
AliAnalysisTaskParticleCorrelation * task = new AliAnalysisTaskParticleCorrelation (Form("PartCorr%s",calorimeter.Data()));
task->SetConfigFileName(""); //Don't configure the analysis via configuration file.
task->SetDebugLevel(debugLevel);
task->SetAnalysisMaker(maker);
if(inputDataType=="ESD" && !kSimulation) task->SelectCollisionCandidates(); //AliPhysicsSelection has to be attached before.
mgr->AddTask(task);
//Create containers
char name[128];
sprintf(name,"PartCorr_%s",calorimeter.Data());
cout<<"Name of task "<<name<<endl;
TString outputfile = AliAnalysisManager::GetCommonFileName();
AliAnalysisDataContainer *cout_pc = mgr->CreateContainer(calorimeter.Data(), TList::Class(),
AliAnalysisManager::kOutputContainer,
Form("%s:PartCorr",outputfile.Data()));
AliAnalysisDataContainer *cout_cuts = mgr->CreateContainer(Form("%sCuts",calorimeter.Data()), TList::Class(),
AliAnalysisManager::kParamContainer,
Form("%s:PartCorrCuts",outputfile.Data()));
// Create ONLY the output containers for the data produced by the task.
// Get and connect other common input/output containers via the manager as below
//==============================================================================
mgr->ConnectInput (task, 0, mgr->GetCommonInputContainer());
// AOD output slot will be used in a different way in future
if(!inputDataType.Contains("delta") && outputAOD) mgr->ConnectOutput (task, 0, mgr->GetCommonOutputContainer());
mgr->ConnectOutput (task, 1, cout_pc);
mgr->ConnectOutput (task, 2, cout_cuts);
return task;
}
AliAnalysisTask *AddTaskFlowTPCEMCalEP(Double_t SigmaITScut, Double_t SigmaTOFcut, Double_t SigmaTPCcut, Double_t AssPtCut, Int_t AssTPCnCut, Int_t ITSncut, Bool_t AssITSrefitCut, Int_t TPCnCut, Int_t period, Bool_t UseNewEP, Bool_t UseTender, TString ID="ContName", TString passV0, TString passTPC, Bool_t TimeCut,Bool_t WeightSyst,Bool_t SystTOFcut, Double_t CutM02, Double_t CutM20, Bool_t SScut, Bool_t EnablePileupRejVZEROTPCout)
{
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
Error("AddTaskFlowTPCEMCalEP", "No analysis manager found.");
return NULL;
}
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskFlowTPCEMCalEP", "This task requires an input event handler");
return NULL;
}
TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
// if (type=="AOD"){
// ::Error("AddTaskFlowTPCEMCalEP", "The tasks exits because AODs are in input");
// return NULL;
// }
Bool_t MCthere=kFALSE;
AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler*>(mgr->GetMCtruthEventHandler());
if(!mcH){
MCthere=kFALSE;
}else{
MCthere=kTRUE;
}
if (!UseNewEP){
//Event plane task
AliEPSelectionTask *eventplaneTask = new AliEPSelectionTask("EventplaneSelection");
eventplaneTask->SelectCollisionCandidates(AliVEvent::kMB | AliVEvent::kSemiCentral | AliVEvent::kCentral | AliVEvent::kEMCEGA | AliVEvent::kEMCEJE);
eventplaneTask->SetTrackType("TPC");
eventplaneTask->SetUsePtWeight();
eventplaneTask->SetUsePhiWeight();
eventplaneTask->SetSaveTrackContribution();
mgr->AddTask(eventplaneTask);
TString containerName0 = mgr->GetCommonFileName();
containerName0 += ":PWGHF_hfeCalEventPlane";
containerName0 += ID;
TString name0 = "EPStat";
name0 += ID;
AliAnalysisDataContainer *cinput0 = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name0.Data(),TList::Class(), AliAnalysisManager::kOutputContainer,containerName0.Data());
mgr->ConnectInput(eventplaneTask, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(eventplaneTask,1,coutput1);
}
Bool_t Is2015 = kTRUE;
if(Is2015){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/PbPb/ConfigHFE_FLOW_TPCEMCal_EP.C");
AliAnalysisTaskFlowTPCEMCalEP *taskMB = ConfigHFE_FLOW_TPCEMCal_EP(MCthere,SigmaITScut,SigmaTOFcut,SigmaTPCcut,AssPtCut,AssTPCnCut,ITSncut,AssITSrefitCut,TPCnCut,UseNewEP,UseTender,period,passV0,passTPC,TimeCut,WeightSyst,SystTOFcut,CutM02,CutM20,SScut,EnablePileupRejVZEROTPCout);
mgr->AddTask(taskMB);
taskMB->SelectCollisionCandidates(AliVEvent::kINT7);
TString containerName1 = mgr->GetCommonFileName();
containerName1 += ":PWGHF_hfeCalcorrINT7V2";
containerName1 += ID;
TString name1 = "histMB";
name1 += ID;
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name1.Data(), TList::Class(),AliAnalysisManager::kOutputContainer, containerName1.Data());
mgr->ConnectInput(taskMB, 0, cinput);
// mgr->ConnectInput(taskMB, 1, corrTask);
mgr->ConnectOutput(taskMB, 1, coutput1);
}
if(!Is2015){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGHF/hfe/macros/configs/PbPb/ConfigHFE_FLOW_TPCEMCal_EP.C");
AliAnalysisTaskFlowTPCEMCalEP *taskMB = ConfigHFE_FLOW_TPCEMCal_EP(MCthere,SigmaITScut,SigmaTOFcut,SigmaTPCcut,AssPtCut,AssTPCnCut,ITSncut,AssITSrefitCut,TPCnCut,UseNewEP,UseTender,period,passV0,passTPC,TimeCut,WeightSyst,SystTOFcut,CutM02,CutM20,SScut,EnablePileupRejVZEROTPCout);
AliAnalysisTaskFlowTPCEMCalEP *taskcorrMB = ConfigHFE_FLOW_TPCEMCal_EP(MCthere,SigmaITScut,SigmaTOFcut,SigmaTPCcut,AssPtCut,AssTPCnCut,ITSncut,AssITSrefitCut,TPCnCut,UseNewEP,UseTender,period,passV0,passTPC,TimeCut,WeightSyst,SystTOFcut,CutM02,CutM20,SScut,EnablePileupRejVZEROTPCout);
AliAnalysisTaskFlowTPCEMCalEP *taskTR = ConfigHFE_FLOW_TPCEMCal_EP(MCthere,SigmaITScut,SigmaTOFcut,SigmaTPCcut,AssPtCut,AssTPCnCut,ITSncut,AssITSrefitCut,TPCnCut,UseNewEP,UseTender,period,passV0,passTPC,TimeCut,WeightSyst,SystTOFcut,CutM02,CutM20,SScut,EnablePileupRejVZEROTPCout);
mgr->AddTask(taskcorrMB);
mgr->AddTask(taskMB);
mgr->AddTask(taskTR);
// Flattened semi central trigger
taskcorrMB->SelectCollisionCandidates(AliVEvent::kAny);
TString containerName1 = mgr->GetCommonFileName();
containerName1 += ":PWGHF_hfeCalcorrSemiCentralV2";
containerName1 += ID;
TString name1 = "histcorrMB";
name1 += ID;
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name1.Data(), TList::Class(),AliAnalysisManager::kOutputContainer, containerName1.Data());
mgr->ConnectInput(taskcorrMB, 0, cinput);
mgr->ConnectOutput(taskcorrMB, 1, coutput1);
// Central trigger
taskMB->SelectCollisionCandidates(AliVEvent::kSemiCentral | AliVEvent::kCentral);
TString containerName2 = mgr->GetCommonFileName();
containerName2 += ":PWGHF_hfeCalCentralV2";
containerName2 += ID;
TString name2 = "histMB";
name2 += ID;
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name2.Data(), TList::Class(),AliAnalysisManager::kOutputContainer, containerName2.Data());
mgr->ConnectInput(taskMB, 0, cinput);
mgr->ConnectOutput(taskMB, 1, coutput1);
//L1 gamma trigger
taskTR->SelectCollisionCandidates(AliVEvent::kEMCEGA);
TString containerName3 = mgr->GetCommonFileName();
containerName3 += ":PWGHF_hfeCalL1GammaV2";
containerName3 += ID;
TString name3 = "histTR";
name3 += ID;
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name3.Data(), TList::Class(),AliAnalysisManager::kOutputContainer, containerName3.Data());
mgr->ConnectInput(taskTR, 0, cinput);
mgr->ConnectOutput(taskTR, 1, coutput1);
}
if(MCthere){
AliAnalysisTaskFlowTPCEMCalEP *taskMC = ConfigHFE_FLOW_TPCEMCal_EP(MCthere,SigmaITScut,SigmaTOFcut,SigmaTPCcut,AssPtCut,AssTPCnCut,ITSncut,AssITSrefitCut,TPCnCut,UseNewEP,UseTender,period,passV0,passTPC,TimeCut,WeightSyst,SystTOFcut,CutM02,CutM20,SScut,EnablePileupRejVZEROTPCout);
mgr->AddTask(taskMC);
taskMC->SelectCollisionCandidates(AliVEvent::kMB);
TString containerName4 = mgr->GetCommonFileName();
containerName4 += ":PWGHF_hfeCalMCV2";
containerName4 += ID;
TString name4 = "histMC";
name4 += ID;
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(name4.Data(), TList::Class(),AliAnalysisManager::kOutputContainer, containerName4.Data());
mgr->ConnectInput(taskMC, 0, cinput);
mgr->ConnectOutput(taskMC, 1, coutput1);
}
return NULL;
}
AliAnalysisTask *AddEbyEPidRatioTaskV1(const Char_t *name = "NuDyn", // 0
Int_t isModeDist = 1, // 1
Bool_t isModeEff = 0, // 2
Bool_t isModeDCA = 0, // 3
Bool_t isModeQA = 0, // 4
Int_t isRatio = 3, // 5
Bool_t isModeAOD = 0, // 6
Bool_t isSetExt = 0, // 7
Int_t aodFilterBit = 1024, // 8
Float_t gEta = 0.8, // 9
Int_t modeCuts = 0, // 10
Int_t modePID =-1, // 11
Float_t gMinPt = 0.3, // 12
Float_t gMaxPt = 2.5, // 13
Float_t gMinPtForTof = 0.21, // 14
Float_t gMaxPtForTPClow = 0.69, // 15
Float_t gY = 0.5, // 16
Float_t gMaxPtEff = 2.5, // 17
Float_t gSigmaITS = 4.0, // 18
Float_t gSigmaTOF = 4.0, // 19
Float_t gSigmaTPC = 4.0, // 20
Float_t gSigmaTPClow = 3.0,
Bool_t isPer = 0,
Int_t nSub = 25) { // 21
TString sName(name);
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
Error("AddTaskNetParticle", "No analysis manager found.");
return NULL;
}
Bool_t isMC = (mgr->GetMCtruthEventHandler() != NULL);
if (isMC)
Info("AddTaskNetParticle", "This task has MC.");
AliEbyEPidRatioTask *task = new AliEbyEPidRatioTask("EbyEPidRatio");
if (!task) {
Error("EbyEPidRatio", "Task could not be created.");
return NULL;
}
if (isMC)
task->SetIsMC();
if (isModeEff)
task->SetModeEffCreation(1); // => 1 = on | 0 = off (default)
if (isModeDCA)
task->SetModeDCACreation(1); // => 1 = on | 0 = off (default)
if (isModeAOD) {
task->SetIsAOD(1); // => 1 = AOD | 0 = ESD (default)
task->SetTrackFilterBit(aodFilterBit);
}
if (isModeQA)
task->SetModeQACreation(1); // => 1 = on | 0 = off (default)
task->SetModeDistCreation(isModeDist); // => 1 = on | 0 = off (default)
task->SetIsRatio(isRatio);
Float_t minPt, maxPt, minPtEff, maxPtEff, minPtForTOF;
Float_t nSigmaITS, nSigmaTPC, nSigmaTPClow, nSigmaTOF, maxPtForTPClow;
Float_t etaMax, etaMaxEff, maxRap;
Int_t pidStrategy;
minPtForTOF = 0.69;
maxPtForTPClow = 0.69;
minPt = 0.5;
maxPt = 2.0;
minPtEff = 0.3;
maxPtEff = 2.5;
maxRap = 0.5;
etaMax = 0.8;
etaMaxEff = 0.8;
nSigmaITS = 4.0;
nSigmaTPC = 4.0;
nSigmaTPClow = 3.0;
nSigmaTOF = 4.0;
if (isSetExt) {
minPt = gMinPt;
maxPt = gMaxPt;
minPtForTOF = gMinPtForTof;
maxPtForTPClow = gMaxPtForTPClow;
minPtEff = gMinPt;
maxPtEff = gMaxPtEff;
maxRap = gY;
etaMax = gEta;
nSigmaITS = gSigmaITS;
nSigmaTPC = gSigmaTPC;
nSigmaTPClow = gSigmaTPClow;
nSigmaTOF = gSigmaTOF;
}
if (modePID == -1) { // default
pidStrategy = 7; // 7: ITS + TPC + TOF (using minPtForTOF)
if (modeCuts == 1)
pidStrategy = 5; // 5: TPC + TOF (using minPtForTOF)
}
else
pidStrategy = modePID;
AliEbyEPidRatioHelper *helper = new AliEbyEPidRatioHelper;
if (!helper) {
Error("AddTaskNetParticle", "Helper could not be created.");
delete task;
return NULL;
}
task->SetESDTrackCutMode(modeCuts); // => 0 = normal | 1 = LF
task->SetEtaMax(etaMax); // eta cut
task->SetEtaMaxEff(etaMaxEff); // eta cut for efficiency
task->SetPtRange(minPt, maxPt); // pt cut range for the analysis
task->SetPtRangeEff(minPtEff, maxPtEff); // pt cut range for the correction / efficiency / contamination creation
if (isPer) task->SetIsPer(); //
helper->SetVertexZMax(10.);
helper->SetCentralityBinMax(11);
helper->SetRapidityMax(maxRap);
helper->SetMinTrackLengthMC(70.);
helper->SetNSigmaMaxCdd(0.); // 3. || ->> Turn off sigmaDCA cuts for now
helper->SetNSigmaMaxCzz(0.); // 3. || ->> Turn off sigmaDCA cuts for now
helper->SetPhiRange(0., 3.88); // Only used if requested in task - default is TwoPi
helper->SetPIDStrategy(pidStrategy);
helper->SetNSigmaMaxITS(nSigmaITS);
helper->SetNSigmaMaxTPC(nSigmaTPC);
helper->SetNSigmaMaxTPClow(nSigmaTPClow);
helper->SetNSigmaMaxTOF(nSigmaTOF);
helper->SetMinPtForTOFRequired(minPtForTOF);
helper->SetMaxPtForTPClow(maxPtForTPClow);
helper->SetNSubSamples(nSub);
task->SetNetParticleHelper(helper);
mgr->AddTask(task);
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
TString outputFileName = Form("%s:%s", AliAnalysisManager::GetCommonFileName(), name);
TString outputQAFileName = Form("%s:%s", AliAnalysisManager::GetCommonFileName(), name);
AliAnalysisDataContainer *coutput = mgr->CreateContainer(name, TList::Class(), AliAnalysisManager::kOutputContainer, outputFileName);
AliAnalysisDataContainer *coutputEff = mgr->CreateContainer(Form("%s_eff", name), TList::Class(), AliAnalysisManager::kOutputContainer, outputFileName);
AliAnalysisDataContainer *coutputCont = mgr->CreateContainer(Form("%s_cont", name), TList::Class(), AliAnalysisManager::kOutputContainer, outputFileName);
AliAnalysisDataContainer *coutputDca = mgr->CreateContainer(Form("%s_dca", name), TList::Class(), AliAnalysisManager::kOutputContainer, outputFileName);
AliAnalysisDataContainer *coutputQA = mgr->CreateContainer(Form("%sQA", name), TList::Class(), AliAnalysisManager::kOutputContainer, outputQAFileName);
mgr->ConnectInput (task, 0, cinput );
mgr->ConnectOutput (task, 1, coutput);
mgr->ConnectOutput (task, 2, coutputEff);
mgr->ConnectOutput (task, 3, coutputCont);
mgr->ConnectOutput (task, 4, coutputDca);
mgr->ConnectOutput (task, 5, coutputQA);
return task;
}
AliAnalysisTaskJetClusterKine *AddTaskJetClusterKine(char* bGen, Char_t *jf, Float_t radius, Int_t kWriteAOD, char *deltaFile, Float_t ptTrackCut, Float_t etaTrackWindow, Float_t vertexWindow){
// Creates a jet fider task, configures it and adds it to the analysis manager.
kPtTrackCutCl = ptTrackCut;
kTrackEtaWindowCl = etaTrackWindow;
kVertexWindowCl = vertexWindow;
TString outputFile(deltaFile);
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if(!mgr){
::Error("AddTaskJetClusterKine", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if(!mgr->GetMCtruthEventHandler()){
::Error("AddTaskJetClusterKine", "This task requires an input MC event handler");
return NULL;
}
TString typeGen(bGen);
typeGen.ToUpper();
// Create the task and configure it.
//===========================================================================
TString cAdd = "";
cAdd += Form("%02d_",TMath::Nint(radius*10.));
cAdd += Form("Cut%05d",TMath::Nint(1000.*kPtTrackCutCl));
Printf("%s %s%s", typeGen.Data(), jf, cAdd.Data());
AliAnalysisTaskJetClusterKine* clus = new AliAnalysisTaskJetClusterKine(Form("JetCluster%s_%s%s",bGen,jf,cAdd.Data()));
// or a config file
clus->SetVtxCuts(kVertexWindowCl);
if(typeGen.Contains("KINECHARGED")){
clus->SetTrackTypeGen(AliAnalysisTaskJetClusterKine::kTrackKineCharged);
clus->SetTrackPtCut(kPtTrackCutCl);
clus->SetTrackEtaWindow(kTrackEtaWindowCl);
}else if(typeGen.Contains("KINEFULL")){
clus->SetTrackTypeGen(AliAnalysisTaskJetClusterKine::kTrackKineAll);
clus->SetTrackPtCut(kPtTrackCutCl);
clus->SetTrackEtaWindow(kTrackEtaWindowCl);
}
clus->SetRparam(radius);
clus->SetGhostArea(0.005);
clus->SetGhostEtamax(kTrackEtaWindowCl);
clus->SetDebugLevel(0);
switch (jf) {
case "ANTIKT":
clus->SetAlgorithm(2); // antikt from fastjet/JetDefinition.hh
break;
case "CA":
clus->SetAlgorithm(1); // CA from fastjet/JetDefinition.hh
break;
case "KT":
clus->SetAlgorithm(0); // kt from fastjet/JetDefinition.hh
break;
default:
::Error("AddTaskJetClusterKine", "Wrong jet finder selected\n");
return 0;
}
TString nameOutArray = Form("clusters%s_%s%s",bGen,jf,cAdd.Data()); //FF//
if(kWriteAOD){
if(outputFile.Length())clus->SetJetOutputFile(outputFile);
Printf("Output branch: %s",nameOutArray.Data());//FF//
clus->SetJetOutputBranch(nameOutArray.Data());//FF//
clus->SetJetOutputMinPt(0); // store only jets / clusters above a certain threshold
}
clus->SetJetOutputContainer(kWriteAOD); //0=no output 1=AOD 2=Exchange
mgr->AddTask(clus);
// Create ONLY the output containers for the data produced by the task.
// Get and connect other common input/output containers via the manager as below
//==============================================================================
AliAnalysisDataContainer *coutput1_clus = mgr->CreateContainer(Form("cluster_%s_%s%s",bGen,jf,cAdd.Data()), TList::Class(),AliAnalysisManager::kOutputContainer,Form("%s:PWGJE_cluster_%s_%s%s",AliAnalysisManager::GetCommonFileName(),bGen,jf,cAdd.Data()));
mgr->ConnectInput (clus, 0, mgr->GetCommonInputContainer());
if(kWriteAOD==1){//FF//
mgr->ConnectOutput (clus, 0, mgr->GetCommonOutputContainer());
}
mgr->ConnectOutput (clus, 1, coutput1_clus );
if(kWriteAOD==2){//FF//
AliAnalysisDataContainer *coutput2_clus = mgr->CreateContainer( nameOutArray.Data(), //??
TClonesArray::Class(),
AliAnalysisManager::kExchangeContainer);
mgr->ConnectOutput (clus, 2, coutput2_clus); //FF//
}
return clus;
}
