AliJJetTask* AddTaskJJet(
// FIXME: Really need default values? Is this needed by AliROOT? Or, let's remove it to reduce mistakes
Int_t trigger = AliVEvent::kEMCEJE,
const char *taskname = "AliJJetTask",
int debug = 1,
int doRecoMCPartleJet = 0, // if do Jet Reconstruction with MC Particle. only for MC
int doRecoTrackJet = 1, // if do Jet Reconstruction with Reconstructed track. both of MC,Data
int isMC = 0, // If this event is MC ( both of particle, track )
int nR = 3, //Number(1-3) of R parameters in order from list 0.4, 0.5, 0.6
int doBackgroundEst = 0 // If user wants to do background estimation with kt-algorithm
)
{
//==============================================================================
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr)
{
::Error("AddTaskJJet", "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("AddTaskJJet", "This task requires an input event handler");
return NULL;
}
//-------------------------------------------------------
// Init the task and do settings
//-------------------------------------------------------
TString name(taskname);
//name += trigger; // FIXME: Why not? Could be
//TString tracksName = "PicoTracks";
//TString tracksName = "PicoTracks";
//TString clustersName = "EmcCaloClusters";
//TString clustersCorrName = "CaloClustersCorr";
TString tracksName = "tracks";
TString clustersCorrName = "caloClusters";
TString tracksNameMC = "mcparticles"; //Check these
TString rhoName = ""; // FIXME: Comment me
if(nR < 1) nR = 1;
if(nR > 3) nR = 3;
//-------------------------------------------------------
// LOAD EMCALJetTasks and Variables
//-------------------------------------------------------
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");
if(doRecoTrackJet){
const int nTrackJetFinder = 2*nR;
}else{
const int nTrackJetFinder = 0;
}
if(doRecoMCPartleJet){
const int nMCParticleJetFinder = 2*nR;
}else{
const int nMCParticleJetFinder = 0;
}
const int nJetFinder = nMCParticleJetFinder + nTrackJetFinder;
if(doBackgroundEst){
if(doRecoTrackJet){
const int nktTrackFinders = 1;
}
else{
const int nktTrackFinders = 0;
}
if(nMCParticleJetFinder){
const int nktMCParticleFinders = 1;
}
else{
const int nktMCParticleFinders = 0;
}
const int nktFinders = nktTrackFinders + nktMCParticleFinders;
}
else{
const int nktFinders = 0;
}
int countJetFinder = 0; // Counter for number of current Jet Finders
//-------------------------------------------------------
// AliJJetTask , AliEmcalJetTask, AliJetContainer
//-------------------------------------------------------
AliJJetTask *jtTask = new AliJJetTask(name, nJetFinder + nktFinders);
jtTask->SetMC( isMC ) ; // Set isMC explicitly.
jtTask->SetnR( nR ) ; // Set number of jet resolution parameters.
jtTask->Setnkt( nktFinders ) ; // Set information about if kt algorithm reconstruction was done or not.
jtTask->SetDebug( debug );
jtTask->SelectCollisionCandidates( trigger ); // WARNING: default is AliVEvent::kEMCEJE. Double check it!
AliEmcalJetTask *jetFinderTask[nJetFinder];
for( int i=0;i<nJetFinder;i++ ) jetFinderTask[i] = NULL;
AliJetContainer *jetCont[nJetFinder];
for( int i=0;i<nJetFinder;i++ ) jetCont[i] = NULL;
AliEmcalJetTask *ktFinderTask[nktFinders];
for( int i=0;i<nktFinders;i++) ktFinderTask[i] = NULL;
AliJetContainer *ktCont[nktFinders]; //0 for Data and 1 for MC. Implementation for different R left for later.
for( int i=0;i<nktFinders;i++) ktCont[i] = NULL;
double ktConeSizes[1]={ 0.4};
int ktJetTypes [1]={ 1};// 0:FullJet 1:Charged
TString ktTypes [1]={"TCP"};// Check if 100% sure about this
//-------------------------------------------------------
// Reconstructed Track Jets : Both of Data, MC
//-------------------------------------------------------
if( doRecoTrackJet ){
//================= Variables for array
int iStart = countJetFinder;
int iEnd = countJetFinder += nTrackJetFinder;
//================= AddTaskEmcalJet
// We have 6 type of recos
double aConeSizes[6]={ 0.4, 0.5, 0.6, 0.4, 0.5, 0.6 };
int aJetType [6]={ 0, 0, 0, 1, 1, 1 }; // 0 :FullJet 1:Charged
TString aType [6]={ "EMCAL", "EMCAL", "EMCAL", "TPC", "TPC", "TPC" };
double bConeSizes[3] = {0.4,0.5,0.6};
int bJetType[2] = {0,1};
int bType[2] = {"EMCAL","TPC"};
//================= Containers : Track, Cluster
AliTrackContainer* partCont = new AliTrackContainer(tracksName);
partCont->SetFilterHybridTracks(kFALSE);
//partCont->SetFilterHybridTracks(kTRUE);
AliParticleContainer *trackCont = partCont;
trackCont->SetClassName("AliVTrack");
//AliParticleContainer *trackCont = jtTask->AddParticleContainer( tracksName );
if (trackCont) jtTask->AdoptParticleContainer(trackCont);
AliClusterContainer *clusterCont = jtTask->AddClusterContainer( clustersCorrName );
clusterCont->SetClassName("AliAODCaloCluster");
//================= LOOP for configuraion
//for(int i=iStart ; i<iEnd; i++){
for(int itype = 0; itype < 2; itype++){
for(int iR = 0; iR < nR; iR++){
int iF = iStart + itype*nR + iR;
//== Variables
//int iHere = iStart - countJetFinder; // array index based 0 in a block
int iHere = i-iStart; // array index based 0 in a block
//double consize = aConeSizes[iHere];
//int jettype = aJetType [iHere];
//int type = aType [iHere];
double consize = bConeSizes[iR];
int jettype = bJetType[itype];
int type = bType[itype];
//== JetFinderTask, JetContainer
TString _clustersCorrName = ( type == "EMCAL" ? clustersCorrName : "" ); // Check if it is EMCAL
jetFinderTask[iF] = AddTaskEmcalJet( tracksName, _clustersCorrName, AliJetContainer::antikt_algorithm, consize, jettype, 0.15, 0.300, 0.005, 1, "Jet", 5. ); // anti-kt
jetFinderTask[iF]->SelectCollisionCandidates(trigger);
jtTask->SetTrackOrMCParticle( iF, AliJJetTask::kJRecoTrack ); // TODO: Move this to AddJetContainer
cout << jetFinderTask[iF]->GetName() << endl;
jetCont[iF] = jtTask->AddJetContainer( jetFinderTask[iF]->GetName(), type, consize ); // TODO: SetTrackOrMCParticle here
if( jetCont[iF] ) {
jetCont[iF]->SetRhoName( rhoName );
jetCont[iF]->ConnectParticleContainer( trackCont );
if ( type == "EMCAL" ) jetCont[iF]->ConnectClusterContainer( clusterCont );
jetCont[iF]->SetZLeadingCut( 0.98, 0.98 ); // FIXME: Comments me and others
jetCont[iF]->SetPercAreaCut( 0.6 );
jetCont[iF]->SetJetPtCut( 5 );
jetCont[iF]->SetLeadingHadronType( 0 );
}
}
} // for i
} // if doRecoTrackJet
//-------------------------------------------------------
// MC Particles Jets
//-------------------------------------------------------
if( doRecoMCPartleJet ){
//================= Variables for array
int iStart = countJetFinder;
int iEnd = countJetFinder += nMCParticleJetFinder; // WARN: this is a real end + 1
//================= AddTaskEmcalJet
// We have 3 type of recos
double aConeSizesMC[6]={ 0.4, 0.5, 0.6, 0.4, 0.5, 0.6 };
int aJetTypeMC [6]={ 0, 0, 0, 1, 1, 1 }; // 0 :FullJet 1:Charged
TString aTypeMC [6]={ "TPC", "TPC", "TPC", "TPC", "TPC", "TPC" };
double bConeSizes[3] = {0.4,0.5,0.6};
int bJetType[2] = {0,1};
int bType[2] = {"EMCAL","TPC"};
char *nrho = rhoName;
//================= Containers : MC Particle
AliMCParticleContainer *mcTrackCont = jtTask->AddMCParticleContainer(tracksNameMC);
mcTrackCont->SelectPhysicalPrimaries(kTRUE);
mcTrackCont->SetClassName("AliAODMCParticle");
//================= LOOP for configuraion
for(int itype = 0; itype < 2; itype++){
for(int iR = 0; iR < nR; iR++){
int iF = iStart + itype*nR + iR;
//== Variables
//int iHere = iStart - countJetFinder; // array index based 0 in a block
//int iHere = i - iStart; // array index based 0 in a block
//double consizeMC = aConeSizesMC[iHere];
//int jettype = aJetTypeMC [iHere];
//int type = aTypeMC [iHere];
double consizeMC = bConeSizes[iR];
int jettype = bJetType[itype];
int type = bType[itype];
//== JetFinderTask, JetContainer
TString _clustersCorrName = ( type == "EMCAL" ? clustersCorrName : "" ); // Check if it is EMCAL // FIXME: Good for MC particles also? //No clusters in mc particles?
jetFinderTask[iF] = AddTaskEmcalJet( tracksNameMC, "", AliJetContainer::antikt_algorithm, consizeMC, jettype, 0.15, 0.300, 0.005, 1, "Jet", 5. ); // anti-kt
jetFinderTask[iF]->SelectCollisionCandidates(trigger);
cout << jetFinderTask[iF]->GetName() << endl;
//jetFinderTask[i]->GetParticleContainer(0)->SelectPhysicalPrimaries(kTRUE);
// FIXME: DUPLICATION? not needed here, I think // FIXME: Why before ConnectParticleContainer? //I don't think the order matters
// FIXME: Is this means, we don't need to make particle container manually?
jtTask->SetTrackOrMCParticle( iF, AliJJetTask::kJMCParticle ); // TODO: Move this to AddJetContainer FIXME: Maybe not possible in easy
jetCont[iF] = jtTask->AddJetContainer( jetFinderTask[iF]->GetName(), type, consizeMC ); // TODO: SetTrackOrMCParticle here
if(jetCont[iF]) {
jetCont[iF]->SetRhoName( rhoName );
jetCont[iF]->ConnectParticleContainer( mcTrackCont );
// if ( aType[iHere] == "EMCAL" ) jetCont[i]->ConnectClusterContainer( clusterCont );
jetCont[iF]->SetZLeadingCut( 0.98, 0.98 ); // FIXME: Comments me and others
jetCont[iF]->SetPercAreaCut( 0.6 );
jetCont[iF]->SetJetPtCut( 5 );
jetCont[iF]->SetLeadingHadronType( 0 );
}
}
} // for i
} // if doRecoMCPartleJet
//-------------------------------------------------------
// kt-algorithm
//-------------------------------------------------------
if (doBackgroundEst) {
double ktConeSize = ktConeSizes[0];
int ktJetType = ktJetTypes[0];
TString ktType = ktTypes[0];
if (doRecoTrackJet) {
TString _clustersCorrName = ( ktType == "EMCAL" ? clustersCorrName : "" );
ktFinderTask[0] = AddTaskEmcalJet( tracksName, _clustersCorrName, AliJetContainer::kt_algorithm, ktConeSize, ktJetType, 0.15, 0.300, 0.005, 1, "Jet", 5. ); // kt
ktFinderTask[0]->SelectCollisionCandidates(trigger);
jtTask->SetTrackOrMCParticle( iEnd, AliJJetTask::kJRecoTrack );
cout << ktFinderTask[0]->GetName() << endl;
ktCont[0] = jtTask->AddJetContainer( ktFinderTask[0]->GetName(), ktJetType, ktConeSize );
if( ktCont[0] ) {
ktCont[0]->SetRhoName( rhoName );
ktCont[0]->ConnectParticleContainer( trackCont );
if ( type == "EMCAL" ) ktCont[0]->ConnectClusterContainer( clusterCont );
ktCont[0]->SetZLeadingCut( 0.98, 0.98 );
ktCont[0]->SetPercAreaCut( 0.6 );
ktCont[0]->SetJetPtCut( 5 );
ktCont[0]->SetLeadingHadronType( 0 );
}
} // if doRecoTrackJet
if (doRecoMCPartleJet) {
TString _clustersCorrName = ( ktType == "EMCAL" ? clustersCorrName : "" );
ktFinderTask[1] = AddTaskEmcalJet( tracksNameMC, "", AliJetContainer::kt_algorithm, ktConeSize, ktJetType, 0.15, 0.300, 0.005, 1, "Jet", 5. ); // kt
ktFinderTask[1]->SelectCollisionCandidates(trigger);
jtTask->SetTrackOrMCParticle( iEnd+1, AliJJetTask::kJMCParticle );
ktCont[1] = jtTask->AddJetContainer( ktFinderTask[1]->GetName(), ktJetType, ktConeSize );
if( ktCont[1] ) {
ktCont[1]->SetRhoName( rhoName );
ktCont[1]->ConnectParticleContainer( trackCont );
if ( type == "EMCAL" ) ktCont[0]->ConnectClusterContainer( clusterCont );
ktCont[1]->SetZLeadingCut( 0.98, 0.98 );
ktCont[1]->SetPercAreaCut( 0.6 );
ktCont[1]->SetJetPtCut( 5 );
ktCont[1]->SetLeadingHadronType( 0 );
}
} // if doRecoTrackJet
} // if doBackgroundEst
//-------------------------------------------------------
// Final settings, pass to manager and set the containers
//-------------------------------------------------------
Printf("name: %s",name.Data());
mgr->AddTask(jtTask);
// Create containers for input/output
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer() ;
TString contname(name);
contname += "_histos";
cout << "Create container " << contname << endl;
AliAnalysisDataContainer *coutput = mgr->CreateContainer(contname.Data(),
TList::Class(),AliAnalysisManager::kOutputContainer,
Form("%s", AliAnalysisManager::GetCommonFileName()));
mgr->ConnectInput (jtTask, 0, cinput );
mgr->ConnectOutput (jtTask, 1, coutput ); // MUST HAVE IT, DON"T KNOW WHY ??? maybe from EMCALJET code
return jtTask;
}
void AddTaskEmcalQA()
{
enum {
kMinBias,
//kEMCalL0,
kEMCalL1G1,
//kEMCalL1G2,
kEMCalL1J1,
//kEMCalL1J2,
//kDCalL0,
kDCalL1G1,
//kDCalL1G2,
kDCalL1J1,
//kDCalL1J2,
kLastTrig
};
TString gCaloTriggerNames[kLastTrig];
gCaloTriggerNames[kMinBias] = "CINT7-B-NOPF-CENT";
//gCaloTriggerNames[kEMCalL0] = "CEMC7-B-NOPF-CENTNOPMD";
gCaloTriggerNames[kEMCalL1G1] = "CINT7EG1-B-NOPF-CENTNOPMD";
//gCaloTriggerNames[kEMCalL1G2] = "CINT7EG2-B-NOPF-CENTNOPMD";
gCaloTriggerNames[kEMCalL1J1] = "CINT7EJ1-B-NOPF-CENTNOPMD";
//gCaloTriggerNames[kEMCalL1J2] = "CINT7EJ2-B-NOPF-CENTNOPMD";
//gCaloTriggerNames[kDCalL0] = "CDMC7-B-NOPF-CENTNOPMD";
gCaloTriggerNames[kDCalL1G1] = "CINT7DG1-B-NOPF-CENTNOPMD";
//gCaloTriggerNames[kDCalL1G2] = "CINT7DG2-B-NOPF-CENTNOPMD";
gCaloTriggerNames[kDCalL1J1] = "CINT7DJ1-B-NOPF-CENTNOPMD";
//gCaloTriggerNames[kDCalL1J2] = "CINT7DJ2-B-NOPF-CENTNOPMD";
TString gCaloTriggerLabels[kLastTrig];
gCaloTriggerLabels[kMinBias] = "INT7";
//gCaloTriggerLabels[kEMCalL0] = "EMC7";
gCaloTriggerLabels[kEMCalL1G1] = "EMCEG1";
//gCaloTriggerLabels[kEMCalL1G2] = "EMCEG2";
gCaloTriggerLabels[kEMCalL1J1] = "EMCEJ1";
//gCaloTriggerLabels[kEMCalL1J2] = "EMCEJ2";
//gCaloTriggerLabels[kDCalL0] = "DMC7";
gCaloTriggerLabels[kDCalL1G1] = "DMCEG1";
//gCaloTriggerLabels[kDCalL1G2] = "DMCEG2";
gCaloTriggerLabels[kDCalL1J1] = "DMCEJ1";
//gCaloTriggerLabels[kDCalL1J2] = "DMCEJ2";
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskSAQA.C");
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskSAJF.C");
gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/AddTaskEmcalTriggerQA.C");
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskRho.C");
AliEmcalJetTask* ktJetTask = AddTaskEmcalJet(AliEmcalJetTask::kKT | AliEmcalJetTask::kFullJet | AliEmcalJetTask::kR020Jet,
"", "CaloClusters", 0., 0.30, 0.005);
AliEmcalJetTask* aktJetTask = AddTaskEmcalJet(AliEmcalJetTask::kAKT | AliEmcalJetTask::kFullJet | AliEmcalJetTask::kR020Jet,
"", "CaloClusters", 0., 0.30, 0.005);
AliAnalysisTaskRho* rhoTaskEMCal = AddTaskRho(ktJetTask->GetName(), "", "CaloClusters", "NeutralRhoEMCal", 0.2, "EMCAL", 0.01, 0, 0, 1, kTRUE, "EMCal");
rhoTaskEMCal->SetUseNewCentralityEstimation(kTRUE);
rhoTaskEMCal->SetNCentBins(5);
rhoTaskEMCal->SetHistoBins(50, 0, 100);
rhoTaskEMCal->GetJetContainer(0)->SetJetPtCut(0.1);
AliAnalysisTaskRho* rhoTaskDCal = AddTaskRho(ktJetTask->GetName(), "", "CaloClusters", "NeutralRhoDCal", 0.2, "DCAL", 0.01, 0, 0, 1, kTRUE, "DCal");
rhoTaskDCal->SetUseNewCentralityEstimation(kTRUE);
rhoTaskDCal->SetNCentBins(5);
rhoTaskDCal->SetHistoBins(50, 0, 100);
rhoTaskDCal->GetJetContainer(0)->SetJetPtCut(0.1);
for (Int_t i = 0; i < kLastTrig; i++) {
TString suffix;
AliEmcalTriggerQATask* pTriggerQA = AddTaskEmcalTriggerQA("EmcalTriggers", 0, 0, gCaloTriggerLabels[i]);
pTriggerQA->SetEMCalTriggerMode(AliAnalysisTaskEmcal::kNoSpecialTreatment);
pTriggerQA->SetTrigClass(gCaloTriggerNames[i]);
pTriggerQA->SetUseNewCentralityEstimation(kTRUE);
pTriggerQA->SetNCentBins(5);
pTriggerQA->SetADCperBin(15);
suffix = gCaloTriggerLabels[i];
AliAnalysisTaskSAQA *pQATaskAfter = AddTaskSAQA("", "CaloClusters", "EMCALCells", "", "",
0, 0, 0, 0., 0., "TPC", suffix);
pQATaskAfter->GetClusterContainer(0)->SetClusECut(0.);
pQATaskAfter->GetClusterContainer(0)->SetClusPtCut(0.);
pQATaskAfter->GetClusterContainer(0)->SetClusNonLinCorrEnergyCut(0.15);
pQATaskAfter->SetDefaultClusterEnergy(AliVCluster::kNonLinCorr);
pQATaskAfter->SetHistoBins(150, 0, 150);
pQATaskAfter->SetEMCalTriggerMode(AliAnalysisTaskEmcal::kNoSpecialTreatment);
pQATaskAfter->SetTrigClass(gCaloTriggerNames[i]);
pQATaskAfter->SetVzRange(-999,999);
pQATaskAfter->SetUseNewCentralityEstimation(kTRUE);
pQATaskAfter->SetNCentBins(5);
if (gCaloTriggerLabels[i] == "INT7" || gCaloTriggerLabels[i].BeginsWith("EMCE")) {
suffix = gCaloTriggerLabels[i];
AliAnalysisTaskSAJF *pJFTask = AddTaskSAJF("", "CaloClusters", aktJetTask->GetName(), "NeutralRhoDCal", 0.2, 1, 0., "EMCALfid", 1, suffix);
pJFTask->SetEMCalTriggerMode(AliAnalysisTaskEmcal::kNoSpecialTreatment);
pJFTask->SetTrigClass(gCaloTriggerNames[i]);
pJFTask->SetVzRange(-999,999);
pJFTask->SetUseNewCentralityEstimation(kTRUE);
pJFTask->SetNCentBins(5);
pJFTask->SetHistoBins(200,0,200);
}
if (gCaloTriggerLabels[i] == "INT7" || gCaloTriggerLabels[i].BeginsWith("DMCE")) {
suffix = gCaloTriggerLabels[i];
AliAnalysisTaskSAJF *pJFTask = AddTaskSAJF("", "CaloClusters", aktJetTask->GetName(), "NeutralRhoEMCal", 0.2, 1, 0., "DCALfid", 1, suffix);
pJFTask->SetEMCalTriggerMode(AliAnalysisTaskEmcal::kNoSpecialTreatment);
pJFTask->SetTrigClass(gCaloTriggerNames[i]);
pJFTask->SetVzRange(-999,999);
pJFTask->SetUseNewCentralityEstimation(kTRUE);
pJFTask->SetNCentBins(5);
pJFTask->SetHistoBins(200,0,200);
}
}
}
AliAnalysisTaskEmcalDiJetAna* AddTaskEmcalDiJetAna(TString kTracksName = "PicoTracks",
TString kClusName = "caloClusterCorr",
Double_t R = 0.4,
Double_t ptminTrack = 0.15,
Double_t etminClus = 0.3,
Int_t rhoType = 0,
TString trigClass = "",
const char *CentEst = "V0A",
Int_t pSel = AliVEvent::kINT7,
Int_t matchFullCh = AliAnalysisTaskEmcalDiJetBase::kNoMatching,
Double_t ptTrackBias = 0.,
Int_t corrType = AliAnalysisTaskEmcalDiJetBase::kCorrelateTwo,
Float_t nefCut = 10.,
Int_t nCentBins = 5,
Double_t scaleFact = 1.28
) {
enum AlgoType {kKT, kANTIKT};
enum JetType {kFULLJETS, kCHARGEDJETS, kNEUTRALJETS};
// #### Define manager and data container names
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskEmcalDiJet", "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("AddTaskEmcalDiJet", "This task requires an input event handler");
return NULL;
}
// #### Add necessary jet finder tasks
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskEmcalJet.C");
AliEmcalJetTask* jetFinderTaskFull = AddTaskEmcalJet(kTracksName, kClusName, kANTIKT, R, kFULLJETS, ptminTrack, etminClus,0.005,1,"Jet",1.);
AliEmcalJetTask* jetFinderTaskCharged = AddTaskEmcalJet(kTracksName, kClusName, kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,1,"Jet",1.);
jetFinderTaskFull->SelectCollisionCandidates(AliVEvent::kAny);
jetFinderTaskCharged->SelectCollisionCandidates(AliVEvent::kAny);
TString strJetsFull = jetFinderTaskFull->GetName();
TString strJetsCh = jetFinderTaskCharged->GetName();
// Add kt jet finder and rho task in case we want background subtraction
gROOT->LoadMacro("$ALICE_PHYSICS/PWGJE/EMCALJetTasks/macros/AddTaskRhoSparse.C");
AliEmcalJetTask *jetFinderKt;
AliEmcalJetTask *jetFinderAKt;
AliAnalysisTaskRhoSparse *rhoTask;
if(rhoType==1) {
jetFinderKt = AddTaskEmcalJet(kTracksName, kClusName, kKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,1,"Jet",0.);
jetFinderAKt = AddTaskEmcalJet(kTracksName, kClusName, kANTIKT, R, kCHARGEDJETS, ptminTrack, etminClus,0.005,1,"Jet",1.);
jetFinderKt->SelectCollisionCandidates(AliVEvent::kAny);
jetFinderAKt->SelectCollisionCandidates(AliVEvent::kAny);
TF1 *fScale = new TF1("fScale","[0]",0.,100.);
fScale->SetParameter(0,scaleFact);
TString rhoSparseName = Form("RhoSparseR%03d",(int)(100*R));
rhoTask = AddTaskRhoSparse(jetFinderKt->GetName(),
jetFinderAKt->GetName(),
kTracksName.Data(),
kClusName.Data(),
rhoSparseName.Data(),
R,
"TPC",
0.01,
0.15,
0,
fScale,
0,
kTRUE,
rhoSparseName.Data(),
kTRUE
);
rhoTask->SetCentralityEstimator(CentEst);
}
TString wagonName = Form("DiJet_%s_%s_Rho%dTC%sMatch%dHadTrig%d",strJetsFull.Data(),strJetsCh.Data(),rhoType,trigClass.Data(),matchFullCh,(Int_t)(ptTrackBias));
//Configure DiJet task
AliAnalysisTaskEmcalDiJetAna *taskDiJet = NULL;
taskDiJet = new AliAnalysisTaskEmcalDiJetAna(wagonName.Data());
taskDiJet->SetUseAliAnaUtils(kTRUE);
taskDiJet->SetVzRange(-10.,10.);
taskDiJet->SetTriggerClass(trigClass.Data());
if(ptminTrack==0.) {
taskDiJet->SetIsPythia(kTRUE);
taskDiJet->SetDoFullFull(kTRUE);
}
taskDiJet->SetJetCorrelationType(corrType);
Printf("strJetsFull: %s",strJetsFull.Data());
Printf("strJetsCh: %s",strJetsCh.Data());
taskDiJet->AddParticleContainer(kTracksName.Data());
taskDiJet->AddClusterContainer(kClusName.Data());
taskDiJet->SetContainerFull(0);
taskDiJet->SetContainerCharged(1);
taskDiJet->AddJetContainer(strJetsFull.Data(),"EMCAL",R);
taskDiJet->AddJetContainer(strJetsCh.Data(),"TPC",R);
taskDiJet->SetZLeadingCut(0.98,0.98,0);
taskDiJet->SetNEFCut(0.,nefCut,0);
for(Int_t i=0; i<2; i++) {
taskDiJet->SetPercAreaCut(0.6, i);
taskDiJet->SetPtBiasJetTrack(ptTrackBias,i);
}
taskDiJet->SetRhoType(rhoType);
if(rhoType==1) {
taskDiJet->SetRhoName(rhoTask->GetOutRhoScaledName(),0);
taskDiJet->SetRhoName(rhoTask->GetOutRhoName(),1);
}
taskDiJet->SetCentralityEstimator(CentEst);
taskDiJet->SetCentRange(0.,100.);
taskDiJet->SetNCentBins(nCentBins);
taskDiJet->SelectCollisionCandidates(pSel);
taskDiJet->SetFullChargedMatchingType(matchFullCh);
taskDiJet->SetDoChargedCharged(kTRUE);
taskDiJet->SetDoFullCharged(kTRUE);
taskDiJet->SetMatchFullCharged(kFALSE);
mgr->AddTask(taskDiJet);
//Connnect input
mgr->ConnectInput (taskDiJet, 0, mgr->GetCommonInputContainer() );
//Connect output
AliAnalysisDataContainer *coutput1 = 0x0;
TString contName(wagonName);
contName += "_histos";
// TString outputfile = Form("%s:%s",AliAnalysisManager::GetCommonFileName(),wagonName.Data());
TString outputfile = Form("%s",AliAnalysisManager::GetCommonFileName());
coutput1 = mgr->CreateContainer(contName.Data(), TList::Class(),AliAnalysisManager::kOutputContainer,outputfile);
mgr->ConnectOutput(taskDiJet,1,coutput1);
return taskDiJet;
}
