void SetEventCuts(AliRsnMiniAnalysisTask *task, Bool_t isMC, ERsnCollisionType collisionType, Double_t vzCut, Bool_t rejectPileUp) { // cut on primary vertex: // - 2nd argument --> |Vz| range // - 3rd argument --> minimum required number of contributors to vtx // - 4th argument --> tells if TPC stand-alone vertexes must be accepted AliRsnCutPrimaryVertex *cutVertex = 0; cutVertex = new AliRsnCutPrimaryVertex("cutEVertex", vzCut, 0, kFALSE); AliRsnCutEventUtils *cutEventUtils = 0; cutEventUtils = new AliRsnCutEventUtils("cutEUtils", kTRUE, rejectPileUp); if ((collisionType == kPP) && (!isMC) && cutVertex) { cutVertex->SetCheckPileUp(rejectPileUp); // set the check for pileup ::Info("AddTaskRsnPhiSpinPol", Form(":::::::::::::::::: Pile-up rejection mode: %s", (rejectPileUp) ? "ON" : "OFF")); } // define and fill cut set for event cut AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent); eventCuts->AddCut(cutEventUtils); eventCuts->AddCut(cutVertex); TString cutScheme = TString::Format("%s&%s", cutEventUtils->GetName(), cutVertex->GetName()); eventCuts->SetCutScheme(cutScheme.Data()); task->SetEventCuts(eventCuts); }
AliRsnCutSet *SetPairCuts(AliRsnMiniAnalysisTask *task, Double_t minY, Double_t maxY) { // -- PAIR CUTS (common to all resonances) // ------------------------------------------------------ AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange); cutY->SetRangeD(minY, maxY); AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother); cutsPair->AddCut(cutY); cutsPair->SetCutScheme(cutY->GetName()); return cutsPair; }
AliRsnCutSet* PairCuts(AliRsnPairDef *support) { // for pairs we define a rapidity windows, defined through a cut // --> NOTE: it needs a support AliRsnPairDef from which it takes the mass AliRsnValueStd *valRapidity = new AliRsnValueStd("valY", AliRsnValueStd::kPairY); AliRsnCutValue *cutRapidity = new AliRsnCutValue("cutY", -0.5, 0.5, kFALSE); valRapidity->SetSupportObject(support); cutRapidity->SetValueObj(valRapidity); // cut set AliRsnCutSet *pairCuts = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother); pairCuts->AddCut(cutRapidity); pairCuts->SetCutScheme(cutRapidity->GetName()); }
AliRsnCutSet* EventCuts() { // primary vertex: // - 2nd argument --> |Vz| range // - 3rd argument --> minimum required number of contributors // - 4th argument --> tells if TPC stand-alone vertexes must be accepted // we switch on the check for pileup AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE); cutVertex->SetCheckPileUp(kTRUE); // primary vertex is always used AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent); eventCuts->AddCut(cutVertex); eventCuts->SetCutScheme(cutVertex->GetName()); return eventCuts; }
AliRsnMiniAnalysisTask * AddTaskRsnQA( Bool_t isMC = kFALSE, Bool_t useGeoCutsPbPb2015 = kFALSE, TString multEstimator = "AliMultSelection_V0M", UInt_t triggerMask = AliVEvent::kINT7, TString outNameSuffix = "phi", Int_t evtCutSetID = 0, //0 for data, 1 for MC, 2 for data with pile-up rejection Int_t pairCutSetID = 0, //selects on pair rapidity: 0 for symmetric system, 1 for p-Pb 5 TeV, 2 for p-Pb 8 TeV Int_t aodFilterBit = 5, //filter bit 5 corresponds to StdITSTPCtrackCuts2011 with TPC crossed rows Bool_t enableMonitor = kTRUE, TString monitorOpt = "NoSIGN") { //------------------------------------------- // event cuts //------------------------------------------- if (evtCutSetID == eventCutSet::kPileUpCut) rejectPileUp = kTRUE; else rejectPileUp = kFALSE; //------------------------------------------- //pair cuts //------------------------------------------- Double_t minYlab = -0.5; Double_t maxYlab = 0.5; if (pairCutSetID==pairYCutSet::kYpPb5TeV) { //-0.5 < y_cm < 0.0 minYlab = -0.465; maxYlab = 0.035; } // if (pairCutSetID==pairYCutSet::kYpPb8TeV) { // //to be calculated // minYlab = -0.9; maxYlab = 0.9; // } // if (pairCutSetID==pairYCutSet::kYPbp5TeV) { // //to be calculated // minYlab = -0.9; maxYlab = 0.9; // } // if (pairCutSetID==pairYCutSet::kYPbp5TeV) { // //to be calculated // minYlab = -0.765; maxYlab = -0.165; // } if (pairCutSetID==pairYCutSet::kYcentralTight) { //|y_cm| < 0.3 minYlab = -0.3; maxYlab = 0.3; } //------------------------------------------- //mixing settings //------------------------------------------- Int_t nmix = 5; Float_t maxDiffVzMix = 1.0; Float_t maxDiffMultMix = 5.0; // // -- INITIALIZATION ---------------------------------------------------------------------------- // retrieve analysis manager // AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskRsnQA", "No analysis manager to connect to."); return NULL; } // create the task and configure TString taskName = Form("taskRsnQA"); AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), kTRUE); //Set trigger selection task->UseESDTriggerMask(triggerMask); //task->SelectCollisionCandidate(triggerMask); /* //Set multiplicity/centrality estimator //if (isPP) task->UseMultiplicity("AliMultSelection_V0M"); //else //task->UseCentrality("V0M"); */ if (multEstimator.IsNull()){ ::Error("AddTaskRsnQA", "No multiplicity selection estimator set."); return NULL; } if (multEstimator.Contains("AliMultSelection")) task->UseMultiplicity(multEstimator.Data()); else task->UseCentrality(multEstimator.Data()); //Set event mixing options task->UseContinuousMix(); task->SetNMix(nmix); task->SetMaxDiffVz(maxDiffVzMix); task->SetMaxDiffMult(maxDiffMultMix); ::Info("AddTaskRsnQA", Form("Event mixing configuration: \n events to mix = %i \n max diff. vtxZ = cm %5.3f \n max diff multi = %5.3f", nmix, maxDiffVzMix, maxDiffMultMix)); //Add task mgr->AddTask(task); // // -- EVENT CUTS (same for all configs) --------------------------------------------------------- // // AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE); //cut on z_vtx < 10 cm // AliRsnCutEventUtils* cutEventUtils=new AliRsnCutEventUtils("cutEventUtils", kTRUE, rejectPileUp); cutEventUtils->SetCheckAcceptedMultSelection(); AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent); eventCuts->AddCut(cutEventUtils); // eventCuts->AddCut(cutVertex); eventCuts->SetCutScheme(Form("%s", cutEventUtils->GetName())); task->SetEventCuts(eventCuts); // // -- EVENT-ONLY COMPUTATIONS ------------------------------------------------------------------- // //vertex Int_t vtxID = task->CreateValue(AliRsnMiniValue::kVz, kFALSE); //multiplicity or centrality Int_t multID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE); AliRsnMiniOutput *outVtx = task->CreateOutput("eventVtx", "HIST", "EVENT"); outVtx->AddAxis(vtxID, 220, -11.0, 11.0); AliRsnMiniOutput *outMult = task->CreateOutput("eventMult", "HIST", "EVENT"); outMult->AddAxis(multID, 101, 0.0, 101.0); //also in pp, p-Pb the percentile is returned TH2F* hvz = new TH2F("hVzVsCent",Form("Vertex position vs centrality"), 101, 0., 101., 220, -11.0, 11.0); hvz->GetXaxis()->SetTitle("multiplicity %"); hvz->GetYaxis()->SetTitle("z_{vtx} (cm)"); task->SetEventQAHist("vz", hvz); // -- PAIR CUTS (common to all resonances) ------------------------------------------------------ AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange); cutY->SetRangeD(minYlab, maxYlab); AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother); cutsPair->AddCut(cutY); cutsPair->SetCutScheme(cutY->GetName()); // // -- CONFIG ANALYSIS -------------------------------------------------------------------------- // gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/qa/ConfigRsnQA.C"); if (!ConfigRsnQA(task, isMC, cutsPair, aodFilterBit, enableMonitor, "NoSIGN", useGeoCutsPbPb2015) ) return 0x0; // -- CONTAINERS -------------------------------------------------------------------------------- TString outputFileName = AliAnalysisManager::GetCommonFileName(); Printf("AddTaskRsnQA - Set OutputFileName : \n %s\n", outputFileName.Data() ); AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnQA_%s", outNameSuffix.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, outputFileName); mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(task, 1, output); return task; }
AliRsnMiniAnalysisTask * AddTaskDeltaPP7TeV ( Bool_t isMC, Bool_t isPP, const char *path, Int_t nmix ) { // // -- INITIALIZATION ---------------------------------------------------------------------------- // // retrieve analysis manager AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); // create the task and connect with physics selection AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask("RSN", isMC); if (isAOD049 && !isMC && !isPP){ task->SetUseCentralityPatch(kTRUE); } mgr->AddTask(task); // settings if (isPP) task->UseMultiplicity("QUALITY"); else task->UseCentrality("V0M"); // set mixing task->UseContinuousMix(); //task->UseBinnedMix(); task->SetNMix(nmix); task->SetMaxDiffVz(1.0); task->SetMaxDiffMult(5.0); task->SetMaxDiffAngle(1E20); // // -- EVENT CUTS (same for all configs) --------------------------------------------------------- // // cut on primary vertex: // - 2nd argument --> |Vz| range // - 3rd argument --> minimum required number of contributors // - 4th argument --> tells if TPC stand-alone vertexes must be accepted AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE); // set the check for pileup if (isPP) cutVertex->SetCheckPileUp(kTRUE); // define and fill cut set AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent); eventCuts->AddCut(cutVertex); eventCuts->SetCutScheme(cutVertex->GetName()); // set cuts in task task->SetEventCuts(eventCuts); // // -- EVENT-ONLY COMPUTATIONS ------------------------------------------------------------------- // // initialize value computation for multiplicity/centrality // second argument tells if the value must be taken from MC // (when this can be done) // after creating the value, the task returns its ID Int_t multID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE); // create event-related output AliRsnMiniOutput *outMult = task->CreateOutput("eventMult", "HIST", "EVENT"); // set axes, by passing value ID and defining the binning if (isPP) outMult->AddAxis(multID, 300, 0.0, 300.0); else outMult->AddAxis(multID, 100, 0.0, 100.0); // // -- PAIR CUTS (common to all resonances) ------------------------------------------------------ // AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange); cutY->SetRangeD(-0.5, 0.5); AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother); cutsPair->AddCut(cutY); cutsPair->SetCutScheme(cutY->GetName()); // // -- CONFIGS ----------------------------------------------------------------------------------- // if (useDelta) { gROOT->LoadMacro("${ALICE_PHYSICS}/PWGLF/RESONANCES/macros/mini/ConfigDeltaPP7TeV.C"); ConfigDeltaPP7TeV(task, isMC, "", cutsPair); if (isMC) { gROOT->LoadMacro("${ALICE_PHYSICS}/PWGLF/RESONANCES/macros/mini/ConfigDeltaPP7TeV_MC.C"); ConfigDeltaPP7TeV_MC(task, isPP, "", cutsPair); } } // // -- CONTAINERS -------------------------------------------------------------------------------- // const char *file = AliAnalysisManager::GetCommonFileName(); AliAnalysisDataContainer *output = mgr->CreateContainer("RsnOut", TList::Class(), AliAnalysisManager::kOutputContainer, file); mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(task, 1, output); return task; }
AliRsnMiniAnalysisTask * AddTaskKStarPP5TeV ( Bool_t isMC = kFALSE, Bool_t isPP = kTRUE, Int_t Strcut = 2011, TString outNameSuffix = "tofveto3stpc2s", Int_t customQualityCutsID = AliRsnCutSetDaughterParticle::kDisableCustom, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate=AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s, Float_t nsigmaPi = 2.0, Float_t nsigmaK = 2.0, Bool_t enableMonitor = kTRUE, Int_t nmix = 5, Float_t maxDiffVzMix = 1.0, Float_t maxDiffMultMix = 5.0 ) { UInt_t triggerMask = AliVEvent::kINT7; Bool_t rejectPileUp = kTRUE; Double_t vtxZcut = 10.0;//cm, default cut on vtx z if(!isPP || isMC) rejectPileUp = kFALSE; // // -- INITIALIZATION ---------------------------------------------------------------------------- // retrieve analysis manager // AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddTaskKStarPP5TeV", "No analysis manager to connect to."); return NULL; } // create the task and configure TString taskName = Form("KStar%s%s", (isPP? "pp" : "PbPb"), (isMC ? "MC" : "Data")); AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), isMC); //task->SelectCollisionCandidates(AliVEvent::kMB); task->UseESDTriggerMask(triggerMask); if (isPP) task->UseMultiplicity("QUALITY"); else task->UseCentrality("V0M"); // set event mixing options task->UseContinuousMix(); //task->UseBinnedMix(); task->SetNMix(nmix); task->SetMaxDiffVz(maxDiffVzMix); task->SetMaxDiffMult(maxDiffMultMix); task->UseMC(isMC); ::Info("AddTaskKStarPP5TeV", Form("Event mixing configuration: \n events to mix = %i \n max diff. vtxZ = cm %5.3f \n max diff multi = %5.3f \n", nmix, maxDiffVzMix, maxDiffMultMix)); mgr->AddTask(task); // // -- EVENT CUTS (same for all configs) --------------------------------------------------------- // // cut on primary vertex: // - 2nd argument --> |Vz| range // - 3rd argument --> minimum required number of contributors // - 4th argument --> tells if TPC stand-alone vertexes must be accepted AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE); if (isPP && (!isMC)) cutVertex->SetCheckPileUp(rejectPileUp); // set the check for pileup cutVertex->SetCheckZResolutionSPD(); cutVertex->SetCheckDispersionSPD(); cutVertex->SetCheckZDifferenceSPDTrack(); AliRsnCutEventUtils* cutEventUtils=new AliRsnCutEventUtils("cutEventUtils",kTRUE,rejectPileUp); cutEventUtils->SetCheckIncompleteDAQ(); cutEventUtils->SetCheckSPDClusterVsTrackletBG(); // define and fill cut set for event cut AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent); eventCuts->AddCut(cutEventUtils); eventCuts->AddCut(cutVertex); eventCuts->SetCutScheme(Form("%s&%s",cutEventUtils->GetName(),cutVertex->GetName())); // set cuts in task task->SetEventCuts(eventCuts); // // -- EVENT-ONLY COMPUTATIONS ------------------------------------------------------------------- // //vertex Int_t vtxID = task->CreateValue(AliRsnMiniValue::kVz, kFALSE); AliRsnMiniOutput *outVtx = task->CreateOutput("eventVtx", "HIST", "EVENT"); outVtx->AddAxis(vtxID, 400, -20.0, 20.0); //multiplicity or centrality Int_t multID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE); AliRsnMiniOutput *outMult = task->CreateOutput("eventMult", "HIST", "EVENT"); if (isPP) outMult->AddAxis(multID, 400, 0.0, 400.0); else outMult->AddAxis(multID, 100, 0.0, 100.0); // // -- PAIR CUTS (common to all resonances) ------------------------------------------------------ // AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange); cutY->SetRangeD(-0.5, 0.5); AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother); cutsPair->AddCut(cutY); cutsPair->SetCutScheme(cutY->GetName()); // // -- CONFIG ANALYSIS -------------------------------------------------------------------------- // gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/ConfigKStarPP5TeV.C"); if (!ConfigKStarPP5TeV(task, isMC, isPP, "", cutsPair, Strcut, customQualityCutsID,cutKaCandidate,nsigmaPi,nsigmaK, enableMonitor)) return 0x0; // // -- CONTAINERS -------------------------------------------------------------------------------- // TString outputFileName = AliAnalysisManager::GetCommonFileName(); // outputFileName += ":Rsn"; Printf("AddTaskKStarPP5TeV - Set OutputFileName : \n %s\n", outputFileName.Data() ); AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnOut_%s",outNameSuffix.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, outputFileName); mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(task, 1, output); return task; }
Int_t AddRsnDaughterCutsLambdaNsigma(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0) { if (!rsnIH) return 0; Bool_t valid = kTRUE; // Int_t collisionType = AliRsnTrainManager::GetGlobalInt("IsCollisionType",valid); Int_t useCommonQualityCut = AliRsnTrainManager::GetGlobalInt("RsnCommonQualityCut",valid); TString rsnQualityCut = AliRsnTrainManager::GetGlobalStr("RsnQualityCut",valid); Int_t isMC = AliRsnTrainManager::GetGlobalInt("IsMC",valid); Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid); Int_t isMixing = AliRsnTrainManager::GetGlobalInt("IsMixing",valid); // === USER HAS TO SET CORRECT NUMBER OF CUTS SETS ===== Int_t numberOfCuts = 2; //--------------------------------------------- // Define single cutsP //--------------------------------------------- Printf("AddRsnDaughterCutsLambda Option : %s",opt.Data()); Double_t nSigmaTPC_P=3.0; Double_t nSigmaTPC_K=3.0; Double_t nSigmaTOF_P=3.0; Double_t nSigmaTOF_K=3.0; Double_t etaRange=0.8; Double_t PtMin_P=0.15; Double_t PtMax_P=1.e10; Double_t PtMin_K=0.15; Double_t PtMax_K=1.e10; Double_t PMax_P=1.1; Double_t PMax_K=0.6; Bool_t useTPC_P=kFALSE; Bool_t useTOF_P=kFALSE; Bool_t rejectUnmatchedTOF_P=kTRUE; Bool_t useTPC_K=kFALSE; Bool_t useTOF_K=kFALSE; Bool_t rejectUnmatchedTOF_K=kTRUE; if (opt.Contains("qualityonly")) { useTPC_P=kFALSE; useTOF_P=kFALSE; useTPC_K=kFALSE; useTOF_K=kFALSE; } else if (!opt.Contains("nsig")) { useTPC_P=kTRUE; useTOF_P=kTRUE; useTPC_K=kTRUE; useTOF_K=kTRUE; } if (opt.Contains("PTPCnsig")) useTPC_P=kTRUE; if (opt.Contains("PTPCnsig10")) nSigmaTPC_P = 1.0; if (opt.Contains("PTPCnsig15")) nSigmaTPC_P = 1.5; if (opt.Contains("PTPCnsig20")) nSigmaTPC_P = 2.0; if (opt.Contains("PTPCnsig25")) nSigmaTPC_P = 2.5; if (opt.Contains("PTPCnsig30")) nSigmaTPC_P = 3.0; if (opt.Contains("PTPCnsig40")) nSigmaTPC_P = 4.0; if (opt.Contains("PTPCnsig50")) nSigmaTPC_P = 5.0; if (opt.Contains("PTPCnsig1000")) nSigmaTPC_P = 100.0; if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE; if (opt.Contains("KTPCnsig10")) nSigmaTPC_K = 1.0; if (opt.Contains("KTPCnsig15")) nSigmaTPC_K = 1.5; if (opt.Contains("KTPCnsig20")) nSigmaTPC_K = 2.0; if (opt.Contains("KTPCnsig25")) nSigmaTPC_K = 2.5; if (opt.Contains("KTPCnsig30")) nSigmaTPC_K = 3.0; if (opt.Contains("KTPCnsig40")) nSigmaTPC_K = 4.0; if (opt.Contains("KTPCnsig50")) nSigmaTPC_K = 5.0; if (opt.Contains("KTPCnsig1000")) nSigmaTPC_K = 100.0; if (opt.Contains("PTOFnsig")) useTOF_P=kTRUE; if (opt.Contains("PTOFacceptUnmatched")) rejectUnmatchedTOF_P=kFALSE; if (opt.Contains("PTOFnsig10")) nSigmaTOF_P = 1.0; if (opt.Contains("PTOFnsig15")) nSigmaTOF_P = 1.5; if (opt.Contains("PTOFnsig20")) nSigmaTOF_P = 2.0; if (opt.Contains("PTOFnsig25")) nSigmaTOF_P = 2.5; if (opt.Contains("PTOFnsig30")) nSigmaTOF_P = 3.0; if (opt.Contains("PTOFnsig40")) nSigmaTOF_P = 4.0; if (opt.Contains("PTOFnsig50")) nSigmaTOF_P = 5.0; if (opt.Contains("PTOFnsig1000")) nSigmaTOF_P = 100.0; if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE; if (opt.Contains("KTOFacceptUnmatched")) rejectUnmatchedTOF_K=kFALSE; if (opt.Contains("KTOFnsig10")) nSigmaTOF_K = 1.0; if (opt.Contains("KTOFnsig15")) nSigmaTOF_K = 1.5; if (opt.Contains("KTOFnsig20")) nSigmaTOF_K = 2.0; if (opt.Contains("KTOFnsig25")) nSigmaTOF_K = 2.5; if (opt.Contains("KTOFnsig30")) nSigmaTOF_K = 3.0; if (opt.Contains("KTOFnsig40")) nSigmaTOF_K = 4.0; if (opt.Contains("KTOFnsig50")) nSigmaTOF_K = 5.0; if (opt.Contains("KTOFnsig1000")) nSigmaTOF_K = 100.0; Bool_t usePDG=kFALSE; if (opt.Contains("pdg")) { Printf("Using PDG"); usePDG = kTRUE; } Bool_t useEta = kFALSE; if (opt.Contains("eta")) { for(int j=1;j<=9;j++) if(opt.Contains(Form("eta0%i",j))) etaRange=0.1*j; Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange); useEta = kTRUE; } Bool_t usePPt=kFALSE; if(opt.Contains("PPt")){ Printf("Using Proton pT range (%.2f,%.2f)",PtMin_P,PtMax_P); usePPt=kTRUE; } Bool_t useKPt=kFALSE; if(opt.Contains("KPt")){ Printf("Using Kaon pT range (%.2f,%.2f)",PtMin_K,PtMax_K); useKPt=kTRUE; } Bool_t usePMax_P=kFALSE; if(opt.Contains("PPMax")){ for(int j=1;j<=9;j++) if(opt.Contains(Form("PPMax0%i",j))) PMax_P=0.1*j; for(int j=10;j<=30;j++) if(opt.Contains(Form("PPMax%i",j))) PMax_P=0.1*j; Printf("Using Proton momentum range (0,%.2f)",PMax_P); usePMax_P=kTRUE; } Bool_t usePMax_K=kFALSE; if(opt.Contains("KPMax")){ for(int j=1;j<=9;j++) if(opt.Contains(Form("KPMax0%i",j))) PMax_K=0.1*j; for(int j=10;j<=30;j++) if(opt.Contains(Form("KPMax%i",j))) PMax_K=0.1*j; Printf("Using Kaon momentum range (0,%.2f)",PMax_K); usePMax_K=kTRUE; } // PROTON SETTINGS =========================================== TString scheme=""; TString cutname = "p_Lambda"; if (!opt.IsNull()) cutname += Form("_%s",opt.Data()); AliRsnCutSet *cutsP = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter); AliRsnCutTrackQuality *qualityCutP = new AliRsnCutTrackQuality("cutQualityP"); if (useCommonQualityCut>=0) { qualityCutP->SetAODTestFilterBit(useCommonQualityCut); } else { qualityCutP->SetDefaults2010(); } cutsP->AddCut(qualityCutP); if (!scheme.IsNull()) scheme += "&"; scheme += qualityCutP->GetName(); if (useTPC_P) { AliRsnCutPIDNSigma *cutPTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCP",AliPID::kProton,AliRsnCutPIDNSigma::kTPC); cutPTPC->SinglePIDRange(nSigmaTPC_P); cutsP->AddCut(cutPTPC); if (!scheme.IsNull()) scheme += "&"; scheme += cutPTPC->GetName(); } if (useTOF_P) { AliRsnCutPIDNSigma *cutPTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFP",AliPID::kProton,AliRsnCutPIDNSigma::kTOF); cutPTOF->SinglePIDRange(nSigmaTOF_P); cutsP->AddCut(cutPTOF); if(rejectUnmatchedTOF_P){ if (!scheme.IsNull()) scheme += "&"; scheme += cutPTOF->GetName(); }else{ AliRsnCutTOFMatch *cutPTOFMatch = new AliRsnCutTOFMatch("cutPTOFMatch"); cutsP->AddCut(cutPTOFMatch); if (!scheme.IsNull()) scheme += "&"; scheme += Form("(%s|(!%s))",cutPTOF->GetName(),cutPTOFMatch->GetName()); } } if (useEta) { AliRsnValueDaughter *valEtaP = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta); AliRsnCutValue *cutEtaP = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange); cutEtaP->SetTargetType(AliRsnTarget::kDaughter); cutEtaP->SetValueObj(valEtaP); cutsP->AddCut(cutEtaP); if (!scheme.IsNull()) scheme += "&"; scheme += cutEtaP->GetName(); } if (usePDG) { AliRsnCutPID *cutPDGP = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE); cutsP->AddCut(cutPDGP); if (!scheme.IsNull()) scheme += "&"; scheme += cutPDGP->GetName(); } if(usePPt){ AliRsnValueDaughter *valPtP = new AliRsnValueDaughter(Form("val%sPt%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kPt); AliRsnCutValue *cutPtP = new AliRsnCutValue(Form("cut%sPt%s",AliPID::ParticleName(type1),opt.Data()),PtMin_P,PtMax_P); cutPtP->SetTargetType(AliRsnTarget::kDaughter); cutPtP->SetValueObj(valPtP); cutsP->AddCut(cutPtP); if (!scheme.IsNull()) scheme += "&"; scheme += cutPtP->GetName(); } if(usePMax_P){ AliRsnValueDaughter *valPP = new AliRsnValueDaughter(Form("val%sP%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kP); AliRsnCutValue *cutPP = new AliRsnCutValue(Form("cut%sP%s",AliPID::ParticleName(type1),opt.Data()),0.,PMax_P); cutPP->SetTargetType(AliRsnTarget::kDaughter); cutPP->SetValueObj(valPP); cutsP->AddCut(cutPP); if (!scheme.IsNull()) scheme += "&"; scheme += cutPP->GetName(); } Printf ("CUT Scheme for PROTON is '%s'",scheme.Data()); cutsP->SetCutScheme(scheme.Data()); // END PROTON ======================================= // KAON SETTINGS ======================================= scheme=""; cutname = "K_Lambda"; if (!opt.IsNull()) cutname += Form("_%s",opt.Data()); AliRsnCutSet *cutsK = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter); AliRsnCutTrackQuality *qualityCutK = new AliRsnCutTrackQuality("cutQualityK"); if (useCommonQualityCut>=0) { qualityCutK->SetAODTestFilterBit(useCommonQualityCut); } else { qualityCutK->SetDefaults2010(); } cutsK->AddCut(qualityCutK); if (!scheme.IsNull()) scheme += "&"; scheme += qualityCutK->GetName(); if (useTPC_K) { AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC); cutKTPC->SinglePIDRange(nSigmaTPC_K); cutsK->AddCut(cutKTPC); if (!scheme.IsNull()) scheme += "&"; scheme += cutKTPC->GetName(); } if (useTOF_K) { AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF); cutKTOF->SinglePIDRange(nSigmaTOF_K); cutsK->AddCut(cutKTOF); if(rejectUnmatchedTOF_K){ if (!scheme.IsNull()) scheme += "&"; scheme += cutKTOF->GetName(); }else{ AliRsnCutTOFMatch *cutKTOFMatch = new AliRsnCutTOFMatch("cutKTOFMatch"); cutsK->AddCut(cutKTOFMatch); if (!scheme.IsNull()) scheme += "&"; scheme += Form("(%s|(!%s))",cutKTOF->GetName(),cutKTOFMatch->GetName()); } } if (useEta) { AliRsnValueDaughter *valEtaK = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kEta); AliRsnCutValue *cutEtaK = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type2),opt.Data()),-etaRange,etaRange); cutEtaK->SetTargetType(AliRsnTarget::kDaughter); cutEtaK->SetValueObj(valEtaK); cutsK->AddCut(cutEtaK); if (!scheme.IsNull()) scheme += "&"; scheme += cutEtaK->GetName(); } if (usePDG) { AliRsnCutPID *cutPDGK = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type2),opt.Data()),type2,0.0,kTRUE); cutsK->AddCut(cutPDGK); if (!scheme.IsNull()) scheme += "&"; scheme += cutPDGK->GetName(); } if(useKPt){ AliRsnValueDaughter *valPtK = new AliRsnValueDaughter(Form("val%sPt%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kPt); AliRsnCutValue *cutPtK = new AliRsnCutValue(Form("cut%sPt%s",AliPID::ParticleName(type2),opt.Data()),PtMin_K,PtMax_K); cutPtK->SetTargetType(AliRsnTarget::kDaughter); cutPtK->SetValueObj(valPtK); cutsK->AddCut(cutPtK); if (!scheme.IsNull()) scheme += "&"; scheme += cutPtK->GetName(); } if(usePMax_K){ AliRsnValueDaughter *valPK = new AliRsnValueDaughter(Form("val%sP%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kP); AliRsnCutValue *cutPK = new AliRsnCutValue(Form("cut%sP%s",AliPID::ParticleName(type2),opt.Data()),0.,PMax_K); cutPK->SetTargetType(AliRsnTarget::kDaughter); cutPK->SetValueObj(valPK); cutsK->AddCut(cutPK); if (!scheme.IsNull()) scheme += "&"; scheme += cutPK->GetName(); } Printf ("CUT Scheme for KAON is '%s'",scheme.Data()); cutsK->SetCutScheme(scheme.Data()); // END KAON ======================================= if (opt.Contains("mon")) { AddMonitorOutput(cutsP->GetMonitorOutput(),opt); AddMonitorOutput(cutsK->GetMonitorOutput(),opt); } if (isRsnMini) { AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task); if (taskRsnMini) { taskRsnMini->AddTrackCuts(cutsP); taskRsnMini->AddTrackCuts(cutsK); } } else { AliRsnDaughterSelector *sel = rsnIH->GetSelector(); // sel->SetLabelCheck(kFALSE); sel->Add(cutsP, kTRUE); sel->Add(cutsK, kTRUE); } return numberOfCuts; }
AliRsnMiniAnalysisTask * AddAnalysisTaskSigmaStarPbPb ( Bool_t isMC, Bool_t isPP, Float_t cutV = 10.0, Int_t aodFilterBit = 5, Int_t piPIDCut = 3.0, Int_t pPIDCut = 3.0, Float_t trackDCAcut = 7.0, Float_t massTol = 0.01, Float_t lambdaDCA = 0.3, Float_t lambdaCosPoinAn = 0.99, Float_t lambdaDaughDCA = 0.5, Int_t NTPCcluster = 70, Int_t nmix = 5, Float_t maxDiffVzMix = 1.0, Float_t maxDiffMultMix = 10.0, Float_t maxDiffAngleMixDeg = 20.0, Int_t aodN = 68, TString outNameSuffix = "Sigma1385" ) { // // -- INITIALIZATION ---------------------------------------------------------------------------- // retrieve analysis manager // AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddAnalysisTaskSigmaStarPbPb", "No analysis manager to connect to."); return NULL; } // create the task and configure TString taskName = Form("SigmaStar%s%s_%.1f_%d_%.1f_%.1f_%.2f_%.2f_%.1f_%.2f_%.1f", (isPP? "pp" : "PbPb"), (isMC ? "MC" : "Data"),cutV,NTPCcluster,piPIDCut,pPIDCut,trackDCAcut,massTol,lambdaDCA,lambdaCosPoinAn,lambdaDaughDCA); AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), isMC); if (!isMC && !isPP){ Printf(Form("========== SETTING USE CENTRALITY PATCH AOD049 : %s", (aodN==49)? "yes" : "no")); task->SetUseCentralityPatch(aodN==49); } if (isPP) task->UseMultiplicity("QUALITY"); else task->UseCentrality("V0M"); // set event mixing options task->UseContinuousMix(); //task->UseBinnedMix(); task->SetNMix(nmix); task->SetMaxDiffVz(maxDiffVzMix); task->SetMaxDiffMult(maxDiffMultMix); if (!isPP) task->SetMaxDiffAngle(maxDiffAngleMixDeg*TMath::DegToRad()); //set angle diff in rad ::Info("AddAnalysisTaskSigmaStarPbPb", Form("Event mixing configuration: \n events to mix = %i \n max diff. vtxZ = cm %5.3f \n max diff multi = %5.3f \n max diff EP angle = %5.3f deg", nmix, maxDiffVzMix, maxDiffMultMix, (isPP ? 0.0 : maxDiffAngleMixDeg))); mgr->AddTask(task); // // -- EVENT CUTS (same for all configs) --------------------------------------------------------- // // cut on primary vertex: // - 2nd argument --> |Vz| range // - 3rd argument --> minimum required number of contributors // - 4th argument --> tells if TPC stand-alone vertexes must be accepted AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", cutV, 0, kFALSE); if (isPP) cutVertex->SetCheckPileUp(kTRUE); // set the check for pileup // define and fill cut set for event cut AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent); eventCuts->AddCut(cutVertex); eventCuts->SetCutScheme(cutVertex->GetName()); // set cuts in task task->SetEventCuts(eventCuts); // // -- EVENT-ONLY COMPUTATIONS ------------------------------------------------------------------- // //vertex Int_t vtxID = task->CreateValue(AliRsnMiniValue::kVz, kFALSE); AliRsnMiniOutput *outVtx = task->CreateOutput("eventVtx", "HIST", "EVENT"); outVtx->AddAxis(vtxID, 400, -20.0, 20.0); //multiplicity or centrality Int_t multID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE); AliRsnMiniOutput *outMult = task->CreateOutput("eventMult", "HIST", "EVENT"); if (isPP) outMult->AddAxis(multID, 400, 0.0, 400.0); else outMult->AddAxis(multID, 100, 0.0, 100.0); //event plane (only for PbPb) Int_t planeID = task->CreateValue(AliRsnMiniValue::kPlaneAngle, kFALSE); AliRsnMiniOutput *outPlane = 0x0; //task->CreateOutput("eventPlane", "HIST", "EVENT"); if (!isPP){ outPlane = task->CreateOutput("eventPlane", "HIST", "EVENT"); outPlane->AddAxis(planeID, 180, 0.0, TMath::Pi()); } // // -- PAIR CUTS (common to all resonances) ------------------------------------------------------ // AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange); cutY->SetRangeD(-0.5, 0.5); AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother); cutsPair->AddCut(cutY); cutsPair->SetCutScheme(cutY->GetName()); // // -- CONFIG ANALYSIS -------------------------------------------------------------------------- gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/ConfigSigmaStarPbPb.C"); if (isMC) { Printf("========================== MC analysis - PID cuts not used"); } else Printf("========================== DATA analysis - PID cuts used"); if (!ConfigSigmaStarPbPb(task, isPP, isMC, piPIDCut, pPIDCut, aodFilterBit, piDCAcut, massTol, lambdaDCA, lambdaCosPoinAn, lambdaDaughDCA, NTPCcluster, "", cutsPair)) return 0x0; // // -- CONTAINERS -------------------------------------------------------------------------------- // TString outputFileName = AliAnalysisManager::GetCommonFileName(); // outputFileName += ":Rsn"; Printf("AddAnalysisTaskSigmaStarPbPb - Set OutputFileName : \n %s\n", outputFileName.Data() ); AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnOut_%s_%.1f_%d_%.1f_%.1f_%.2f_%.2f_%.1f_%.2f_%.1f",outNameSuffix.Data(),cutV,NTPCcluster,piPIDCut,pPIDCut,trackDCAcut,massTol,lambdaDCA,lambdaCosPoinAn,lambdaDaughDCA), TList::Class(), AliAnalysisManager::kOutputContainer, outputFileName); mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(task, 1, output); return task; }
Bool_t AddAnalysisTaskRsn ( Bool_t isMC, Bool_t useCentrality, Bool_t checkPileUp, const char *path = "$(HOME)/code/resonances/alice-rsn-package/PWG2resonances/RESONANCES/macros/test/pulvir" ) { // // -- INITIALIZATION ---------------------------------------------------------------------------- // // retrieve analysis manager AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); // create the task and connect with physics selection AliRsnAnalysisTask *task = new AliRsnAnalysisTask("RSN"); task->SelectCollisionCandidates(); mgr->AddTask(task); // // -- EVENT CUTS (same for all configs) --------------------------------------------------------- // // cut on primary vertex: // - 2nd argument --> |Vz| range // - 3rd argument --> minimum required number of contributors // - 4th argument --> tells if TPC stand-alone vertexes must be accepted AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE); // set the check for pileup ::Info("AddAnalysisTaskRsn", "Check of pile-up from SPD is %s", (checkPileUp ? "active" : "disabled")); cutVertex->SetCheckPileUp(checkPileUp); // define and fill cut set AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent); eventCuts->AddCut(cutVertex); eventCuts->SetCutScheme(cutVertex->GetName()); // // -- CONFIGS ----------------------------------------------------------------------------------- // // add configs and count how many are added // will return kFALSE if none is added Int_t added = 0; if (useTest) { // NOTE: this is a test and will had its own definition of event cuts // ----> will not use those defined above gROOT->LoadMacro(Form("%s/RsnConfigTest.C", path)); if (!RsnConfigTest(task, isMC)) return kFALSE; added++; } if (useEvent) { gROOT->LoadMacro(Form("%s/RsnConfigEvent.C", path)); if (!RsnConfigEvent(task, isMC, useCentrality, eventCuts)) return kFALSE; added++; } if (useKaonMonitor) { gROOT->LoadMacro(Form("%s/RsnConfigMonitorTPC.C", path)); if (!RsnConfigMonitorTPC(task, isMC, useCentrality, eventCuts)) return kFALSE; added++; } if (usePhiTPC) { gROOT->LoadMacro(Form("%s/RsnConfigPhiTPC.C", path)); if (!RsnConfigPhiTPC(task, isMC, useCentrality, eventCuts)) return kFALSE; added++; } if (useKStarTPC) { gROOT->LoadMacro(Form("%s/RsnConfigKStarTPC.C", path)); if (!RsnConfigKStarTPC(task, isMC, useCentrality, eventCuts)) return kFALSE; added++; } ::Info("AddAnalysisTaskRsn.C", "Added %d configs", added); if (!added) { ::Error("AddAnalysisTaskRsn.C", "Cannot process an empty task!"); return kFALSE; } // // -- CONTAINERS -------------------------------------------------------------------------------- // const char *file = AliAnalysisManager::GetCommonFileName(); AliAnalysisDataContainer *output = mgr->CreateContainer("RsnOut", TList::Class(), AliAnalysisManager::kOutputContainer, file); mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(task, 1, output); return kTRUE; }
Int_t AddRsnDaughterCutsKStarTOFanalysis(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0) { if (!rsnIH) return 0; Bool_t valid; Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid); // === USER HAS TO SET CORRECT NUMBER OF CUTS SETS ===== Int_t numberOfCuts = 2; //--------------------------------------------- // Define single cutsP //--------------------------------------------- Printf("AddRsnDaughterCutsKStarTOFanalysis Option : %s",opt.Data()); // default values Double_t nSigmaTPC_Pi=3.0; Double_t nSigmaTPC_K=3.0; Double_t nSigmaTOF_Pi=3.0; Double_t nSigmaTOF_K=3.0; Double_t nSigmaTPCveto_Pi=5.0; Double_t nSigmaTPCveto_K=5.0; Double_t etaRange=0.8; Bool_t useTPC_Pi=kFALSE; Bool_t useTOF_Pi=kFALSE; Bool_t useTPC_K=kFALSE; Bool_t useTOF_K=kFALSE; Bool_t useTPCveto_Pi = kFALSE; Bool_t useTPCveto_K = kFALSE; Bool_t useCombined_Pi = kFALSE; Bool_t useCombined_K = kFALSE; if (opt.Contains("qualityonly")) { useTPC_Pi=kFALSE; useTOF_Pi=kFALSE; useTPC_K=kFALSE; useTOF_K=kFALSE; useTPCveto_Pi = kFALSE; useTPCveto_K = kFALSE; useCombined_Pi = kFALSE; useCombined_K = kFALSE; } else { if (opt.Contains("combined")) { useCombined_Pi = kTRUE; useCombined_K = kTRUE; } else { if (opt.Contains("PiTPCnsig")) useTPC_Pi=kTRUE; if (opt.Contains("PiTOFnsig")) useTOF_Pi=kTRUE; if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE; if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE; if(opt.Contains("TPCveto")) { useTPCveto_Pi = kTRUE; useTPCveto_K = kTRUE; nSigmaTPCveto_Pi = 5.0; nSigmaTPCveto_K = 5.0; } } } if (opt.Contains("PiTPCnsig10")) nSigmaTPC_Pi = 1.0; if (opt.Contains("PiTPCnsig15")) nSigmaTPC_Pi = 1.5; if (opt.Contains("PiTPCnsig20")) nSigmaTPC_Pi = 2.0; if (opt.Contains("PiTPCnsig25")) nSigmaTPC_Pi = 2.5; if (opt.Contains("PiTPCnsig30")) nSigmaTPC_Pi = 3.0; if (opt.Contains("KTPCnsig10")) nSigmaTPC_K = 1.0; if (opt.Contains("KTPCnsig15")) nSigmaTPC_K = 1.5; if (opt.Contains("KTPCnsig20")) nSigmaTPC_K = 2.0; if (opt.Contains("KTPCnsig25")) nSigmaTPC_K = 2.5; if (opt.Contains("KTPCnsig30")) nSigmaTPC_K = 3.0; if (opt.Contains("PiTOFnsig10")) nSigmaTOF_Pi = 1.0; if (opt.Contains("PiTOFnsig15")) nSigmaTOF_Pi = 1.5; if (opt.Contains("PiTOFnsig20")) nSigmaTOF_Pi = 2.0; if (opt.Contains("PiTOFnsig25")) nSigmaTOF_Pi = 2.5; if (opt.Contains("PiTOFnsig30")) nSigmaTOF_Pi = 3.0; if (opt.Contains("KTOFnsig10")) nSigmaTOF_K = 1.0; if (opt.Contains("KTOFnsig15")) nSigmaTOF_K = 1.5; if (opt.Contains("KTOFnsig20")) nSigmaTOF_K = 2.0; if (opt.Contains("KTOFnsig25")) nSigmaTOF_K = 2.5; if (opt.Contains("KTOFnsig30")) nSigmaTOF_K = 3.0; Bool_t usePDG=kFALSE; if (opt.Contains("pdg")) { Printf("Using PDG"); usePDG = kTRUE; } Bool_t useEta = kFALSE; if (opt.Contains("eta")) { Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange); useEta = kTRUE; } // KAON SETTINGS ======================================= TString scheme=""; TString cutname = "K_Kstar"; if (!opt.IsNull()) cutname += Form("_%s",opt.Data()); AliRsnCutSet *cutsK; if (useCombined_K) { cutsK = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPP2010, AliPID::kKaon, nSigmaTOF_K, 5); if (!scheme.IsNull()) scheme += "&"; scheme += cutsK->GetCutScheme(); } else { if (useTPCveto_K) { cutsK = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010, AliPID::kKaon, nSigmaTOF_K, 5); if (!scheme.IsNull()) scheme += "&"; scheme += cutsK->GetCutScheme(); } else { cutsK = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter); AliRsnCutTrackQuality *qualityCutK = new AliRsnCutTrackQuality("cutQuatityK"); qualityCutK->SetDefaults2010(); cutsK->AddCut(qualityCutK); if (!scheme.IsNull()) scheme += "&"; scheme += qualityCutK->GetName(); if (useTPC_K) { AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC); cutKTPC->SinglePIDRange(nSigmaTPC_K); cutsK->AddCut(cutKTPC); if (!scheme.IsNull()) scheme += "&"; scheme += cutKTPC->GetName(); } if (useTOF_K) { AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF); cutKTOF->SinglePIDRange(nSigmaTOF_K); cutsK->AddCut(cutKTOF); if (!scheme.IsNull()) scheme += "&"; scheme += cutKTOF->GetName(); } } } if (useEta) { AliRsnValueDaughter *valEtaK = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kEta); AliRsnCutValue *cutEtaK = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type2),opt.Data()),-etaRange,etaRange); cutEtaK->SetTargetType(AliRsnTarget::kDaughter); cutEtaK->SetValueObj(valEtaK); cutsK->AddCut(cutEtaK); if (!scheme.IsNull()) scheme += "&"; scheme += cutEtaK->GetName(); } if (usePDG) { AliRsnCutPID *cutPDGK = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type2),opt.Data()),type2,0.0,kTRUE); cutsK->AddCut(cutPDGK); if (!scheme.IsNull()) scheme += "&"; scheme += cutPDGK->GetName(); } Printf ("CUT Scheme for KAON is '%s'",scheme.Data()); cutsK->SetCutScheme(scheme.Data()); // END KAON ======================================= // Pion SETTINGS =========================================== scheme=""; cutname = "Pi_Kstar"; if (!opt.IsNull()) cutname += Form("_%s",opt.Data()); AliRsnCutSet *cutsPi; if (useCombined_Pi) { cutsPi = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPP2010, AliPID::kPion, nSigmaTOF_Pi, 5); if (!scheme.IsNull()) scheme += "&"; scheme += cutsPi->GetCutScheme(); } else { if (useTPCveto_Pi) { cutsPi = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010, AliPID::kPion, nSigmaTOF_Pi, 5); if (!scheme.IsNull()) scheme += "&"; scheme += cutsPi->GetCutScheme(); } else { cutsPi = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter); AliRsnCutTrackQuality *qualityCutPi = new AliRsnCutTrackQuality("cutQuatityPi"); qualityCutPi->SetDefaults2010(); cutsPi->AddCut(qualityCutPi); if (!scheme.IsNull()) scheme += "&"; scheme += qualityCutPi->GetName(); if (useTPC_Pi) { AliRsnCutPIDNSigma *cutPiTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCPi",AliPID::kPion,AliRsnCutPIDNSigma::kTPC); cutPiTPC->SinglePIDRange(nSigmaTPC_Pi); cutsPi->AddCut(cutPiTPC); if (!scheme.IsNull()) scheme += "&"; scheme += cutPiTPC->GetName(); } if (useTOF_Pi) { AliRsnCutPIDNSigma *cutPiTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFPi",AliPID::kPion,AliRsnCutPIDNSigma::kTOF); cutPiTOF->SinglePIDRange(nSigmaTOF_Pi); cutsPi->AddCut(cutPiTOF); if (!scheme.IsNull()) scheme += "&"; scheme += cutPiTOF->GetName(); } } } if (useEta) { AliRsnValueDaughter *valEtaP = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta); AliRsnCutValue *cutEtaP = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange); cutEtaP->SetTargetType(AliRsnTarget::kDaughter); cutEtaP->SetValueObj(valEtaP); cutsPi->AddCut(cutEtaP); if (!scheme.IsNull()) scheme += "&"; scheme += cutEtaP->GetName(); } if (usePDG) { AliRsnCutPID *cutPDGP = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE); cutsPi->AddCut(cutPDGP); if (!scheme.IsNull()) scheme += "&"; scheme += cutPDGP->GetName(); } Printf ("CUT Scheme for PROTON is '%s'",scheme.Data()); cutsPi->SetCutScheme(scheme.Data()); // END PION ======================================= if (opt.Contains("mon")) { AddMonitorOutput(cutsPi->GetMonitorOutput(),opt); AddMonitorOutput(cutsK->GetMonitorOutput(),opt); } if (isRsnMini) { AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task); if (taskRsnMini) { taskRsnMini->AddTrackCuts(cutsK); taskRsnMini->AddTrackCuts(cutsPi); } } else { AliRsnDaughterSelector *sel = rsnIH->GetSelector(); // sel->SetLabelCheck(kFALSE); sel->Add(cutsPi, kTRUE); sel->Add(cutsK, kTRUE); } return numberOfCuts; }
AliRsnMiniAnalysisTask * AddAnalysisTaskTPCKStar ( Bool_t isMC, Bool_t isPP, Int_t aodFilterBit = 5, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutPiCandidate = AliRsnCutSetDaughterParticle::kFastTPCpidNsigma, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate = AliRsnCutSetDaughterParticle::kFastTPCpidNsigma, Float_t nsigmaPi = 2.0, Float_t nsigmaKa = 2.0, Bool_t enableMonitor = kTRUE, Bool_t IsMcTrueOnly = kFALSE, UInt_t triggerMask = AliVEvent::kMB, Int_t PbPb2011CentFlat = 0, Int_t nmix = 0, Float_t maxDiffVzMix = 1.0, Float_t maxDiffMultMix = 10.0, Float_t maxDiffAngleMixDeg = 20.0, Int_t aodN = 0, TString outNameSuffix = "" ) { // // -- INITIALIZATION ---------------------------------------------------------------------------- // retrieve analysis manager // AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddAnalysisTaskTPCKStar", "No analysis manager to connect to."); return NULL; } // create the task and configure TString taskName = Form("TPCKStar%s%s_%i%i_%s", (isPP? "pp" : "PbPb"), (isMC ? "MC" : "Data"), (Int_t)cutPiCandidate,(Int_t)cutKaCandidate, outNameSuffix.Data() ); AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), isMC); if (!isMC && !isPP){ Printf(Form("========== SETTING USE CENTRALITY PATCH AOD049 : %s", (aodN==49)? "yes" : "no")); task->SetUseCentralityPatch(aodN==49); } //centrality flatening patch LHC11h if(PbPb2011CentFlat) task->SetUseCentralityPatchPbPb2011(PbPb2011CentFlat); //task->SelectCollisionCandidates(AliVEvent::kMB | AliVEvent::kCentral | AliVEvent::kSemiCentral); task->SelectCollisionCandidates(triggerMask); if (isPP) task->UseMultiplicity("QUALITY"); else task->UseCentrality("V0M"); // set event mixing options task->UseContinuousMix(); //task->UseBinnedMix(); task->SetNMix(nmix); task->SetMaxDiffVz(maxDiffVzMix); task->SetMaxDiffMult(maxDiffMultMix); if (!isPP) task->SetMaxDiffAngle(maxDiffAngleMixDeg*TMath::DegToRad()); //set angle diff in rad ::Info("AddAnalysisTaskTPCKStar", Form("Event mixing configuration: \n events to mix = %i \n max diff. vtxZ = cm %5.3f \n max diff multi = %5.3f \n max diff EP angle = %5.3f deg", nmix, maxDiffVzMix, maxDiffMultMix, (isPP ? 0.0 : maxDiffAngleMixDeg))); mgr->AddTask(task); // // -- EVENT CUTS (same for all configs) --------------------------------------------------------- // // cut on primary vertex: // - 2nd argument --> |Vz| range // - 3rd argument --> minimum required number of contributors // - 4th argument --> tells if TPC stand-alone vertexes must be accepted AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE); if (isPP) cutVertex->SetCheckPileUp(kTRUE); // set the check for pileup // define and fill cut set for event cut AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent); eventCuts->AddCut(cutVertex); eventCuts->SetCutScheme(cutVertex->GetName()); // set cuts in task task->SetEventCuts(eventCuts); // // -- EVENT-ONLY COMPUTATIONS ------------------------------------------------------------------- // //vertex Int_t vtxID = task->CreateValue(AliRsnMiniValue::kVz, kFALSE); AliRsnMiniOutput *outVtx = task->CreateOutput("eventVtx", "HIST", "EVENT"); outVtx->AddAxis(vtxID, 400, -20.0, 20.0); //multiplicity or centrality Int_t multID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE); AliRsnMiniOutput *outMult = task->CreateOutput("eventMult", "HIST", "EVENT"); if (isPP) outMult->AddAxis(multID, 400, 0.0, 400.0); else outMult->AddAxis(multID, 100, 0.0, 100.0); //event plane (only for PbPb) Int_t planeID = task->CreateValue(AliRsnMiniValue::kPlaneAngle, kFALSE); AliRsnMiniOutput *outPlane = task->CreateOutput("eventPlane", "HIST", "EVENT"); if (!isPP) outPlane->AddAxis(planeID, 180, 0.0, TMath::Pi()); // // -- PAIR CUTS (common to all resonances) ------------------------------------------------------ // AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange); cutY->SetRangeD(-0.5, 0.5); AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother); cutsPair->AddCut(cutY); cutsPair->SetCutScheme(cutY->GetName()); // // -- CONFIG ANALYSIS -------------------------------------------------------------------------- if(!isMC){ gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/ConfigTPCanalysisKStar.C"); if (!ConfigTPCanalysisKStar(task, isMC, isPP, "", cutsPair, aodFilterBit, cutPiCandidate, cutKaCandidate, nsigmaPi, nsigmaKa, enableMonitor, isMC&IsMcTrueOnly, aodN)) return 0x0; } else { gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/ConfigTPCanalysisKStarMC.C"); if (!ConfigTPCanalysisKStarMC(task, isMC, isPP, "", cutsPair, aodFilterBit, cutPiCandidate, cutKaCandidate, nsigmaPi, nsigmaKa, enableMonitor, isMC&IsMcTrueOnly, 313, aodN)) return 0x0; //K* if (!ConfigTPCanalysisKStarMC(task, isMC, isPP, "", cutsPair, aodFilterBit, cutPiCandidate, cutKaCandidate, nsigmaPi, nsigmaKa, enableMonitor, isMC&IsMcTrueOnly, -313, aodN)) return 0x0; //anti-K* } // // -- CONTAINERS -------------------------------------------------------------------------------- // TString outputFileName = AliAnalysisManager::GetCommonFileName(); // outputFileName += ":Rsn"; Printf("AddAnalysisTaskTPCKStar - Set OutputFileName : \n %s\n", outputFileName.Data() ); AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnOut_%s",outNameSuffix.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, outputFileName); mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(task, 1, output); return task; }
Int_t AddRsnDaughterCutsPhiNsigma(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0) { if (!rsnIH) return 0; Bool_t valid = kTRUE; // Int_t collisionType = AliRsnTrainManager::GetGlobalInt("IsCollisionType",valid); Int_t useCommonQualityCut = AliRsnTrainManager::GetGlobalInt("RsnCommonQualityCut",valid); TString rsnQualityCut = AliRsnTrainManager::GetGlobalStr("RsnQualityCut",valid); Int_t isMC = AliRsnTrainManager::GetGlobalInt("IsMC",valid); Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid); Int_t isMixing = AliRsnTrainManager::GetGlobalInt("IsMixing",valid); // experts only (don't touch) Int_t isRsnDev = AliAnalysisManager::GetGlobalInt("rsnUseRSNParDev",valid); // === USER HAS TO SET CORRECT NUMBER OF CUTS SETS ===== Int_t numberOfCuts = 1; //--------------------------------------------- // Define single cuts //--------------------------------------------- Printf("AliRsnCutPIDNSigma Option : %s",opt.Data()); Double_t nSigmaTPC=3.0; Double_t nSigmaTOF=3.0; Double_t etaMin=-0.8; Double_t etaMax=0.8; Double_t trackPtMin=0.; Double_t trackPtMax=1.e10; Int_t NclTPC=70; Char_t DCAxyFormula[100]="0.0182+0.035/pt^1.01"; Bool_t useTPC_K=kFALSE; Bool_t useTOF_K=kFALSE; Bool_t rejectUnmatchedTOF_K=kTRUE; Bool_t useTrackPtCut=kFALSE; if (opt.Contains("qualityonly")) { useTPC_K=kFALSE; useTOF_K=kFALSE; } if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE; if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE; if (opt.Contains("KTOFacceptUnmatched")) rejectUnmatchedTOF_K=kFALSE; if (opt.Contains("KTPCnsig05")) nSigmaTPC = 0.5; if (opt.Contains("KTPCnsig08")) nSigmaTPC = 0.8; if (opt.Contains("KTPCnsig10")) nSigmaTPC = 1.0; if (opt.Contains("KTPCnsig15")) nSigmaTPC = 1.5; if (opt.Contains("KTPCnsig20")) nSigmaTPC = 2.0; if (opt.Contains("KTPCnsig25")) nSigmaTPC = 2.5; if (opt.Contains("KTPCnsig30")) nSigmaTPC = 3.0; if (opt.Contains("KTPCnsig40")) nSigmaTPC = 4.0; if (opt.Contains("KTPCnsig50")) nSigmaTPC = 5.0; if (opt.Contains("KTPCnsig1000")) nSigmaTPC = 100.0; if (opt.Contains("KTOFnsig10")) nSigmaTOF = 1.0; if (opt.Contains("KTOFnsig15")) nSigmaTOF = 1.5; if (opt.Contains("KTOFnsig20")) nSigmaTOF = 2.0; if (opt.Contains("KTOFnsig25")) nSigmaTOF = 2.5; if (opt.Contains("KTOFnsig30")) nSigmaTOF = 3.0; if (opt.Contains("KTOFnsig40")) nSigmaTOF = 4.0; if (opt.Contains("KTOFnsig50")) nSigmaTOF = 5.0; if (opt.Contains("KTOFnsig1000")) nSigmaTOF = 100.0; if (opt.Contains("trackPt")) { useTrackPtCut = kTRUE; if (opt.Contains("trackPtMin015")) trackPtMin = 0.15; if (opt.Contains("trackPtMin02")) trackPtMin = 0.2; if (opt.Contains("trackPtMin05")) trackPtMin = 0.5; if (opt.Contains("trackPtMin06")) trackPtMin = 0.6; if (opt.Contains("trackPtMax18")) trackPtMax = 1.8; if (opt.Contains("trackPtMax20")) trackPtMax = 2.0; if (opt.Contains("trackPtMax25")) trackPtMax = 2.5; } Bool_t usePDG=kFALSE; if (opt.Contains("pdg")) { Printf("Using PDG"); usePDG = kTRUE; } Bool_t useEta = kFALSE; if (opt.Contains("eta")) { for(int j=1;j<=9;j++) if(opt.Contains(Form("eta0%i",j))){etaMin=-0.1*j; etaMax=0.1*j;} for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMinMinus0%i",j))) etaMin=-0.1*j; if(opt.Contains("etaMin00")) etaMin=0.; for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMinPlus0%i",j))) etaMin=0.1*j; for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMaxMinus0%i",j))) etaMax=-0.1*j; if(opt.Contains("etaMax00")) etaMax=0.; for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMaxPlus0%i",j))) etaMax=0.1*j; Printf("Using ETA range (%.2f,%.2f)",etaMin,etaMax); useEta = kTRUE; } Bool_t useNclTPC = kFALSE; if (opt.Contains("NclTPC")) { if (opt.Contains("NclTPC70")) NclTPC=70; if (opt.Contains("NclTPC75")) NclTPC=75; if (opt.Contains("NclTPC80")) NclTPC=80; if (opt.Contains("NclTPC85")) NclTPC=85; if (opt.Contains("NclTPC90")) NclTPC=90; useNclTPC = kTRUE; } Bool_t useDCAxy = kFALSE; if (opt.Contains("DCAxy")) { if (opt.Contains("DCAxyFormula7s")) sprintf(DCAxyFormula,"0.0182+0.035/pt^1.01"); if (opt.Contains("DCAxyFormula6s")) sprintf(DCAxyFormula,"0.0156+0.03/pt^1.01"); if (opt.Contains("DCAxyFormula5s")) sprintf(DCAxyFormula,"0.013+0.025/pt^1.01"); useDCAxy = kTRUE; } //--------------------------------------------- // Combine cuts //--------------------------------------------- TString cutname = "K_Phi"; if (!opt.IsNull()) cutname += Form("_%s",opt.Data()); AliRsnCutSet *cuts = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter); TString scheme=""; AliRsnCutTrackQuality *qualityCut = new AliRsnCutTrackQuality("cutQualityK"); if (!rsnQualityCut.IsNull()) { AliESDtrackCuts *esdTK = RsnQualityCut(rsnQualityCut.Data()); if(useDCAxy) esdTK->SetMaxDCAToVertexXYPtDep(DCAxyFormula); qualityCut->SetESDtrackCuts(esdTK); } else { if (useCommonQualityCut>=0) { qualityCut->SetAODTestFilterBit(useCommonQualityCut); if(useDCAxy) {qualityCut->SetCheckOnlyFilterBit(kFALSE); qualityCut->SetDCARPtFormula(DCAxyFormula);} } else { qualityCut->SetDefaults2010(); if(useDCAxy) qualityCut->SetDCARPtFormula(DCAxyFormula); } } cuts->AddCut(qualityCut); if (!scheme.IsNull()) scheme += "&"; scheme += qualityCut->GetName(); if (useTPC_K) { AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutPIDNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC); cutKTPC->SinglePIDRange(nSigmaTPC); cuts->AddCut(cutKTPC); if (!scheme.IsNull()) scheme += "&"; scheme += cutKTPC->GetName(); } if (useTOF_K) { AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutPIDNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF); cutKTOF->SinglePIDRange(nSigmaTOF); cuts->AddCut(cutKTOF); if(rejectUnmatchedTOF_K){ if (!scheme.IsNull()) scheme += "&"; scheme += cutKTOF->GetName(); }else{ AliRsnCutTOFMatch *cutKTOFMatch = new AliRsnCutTOFMatch("cutKTOFMatch"); cuts->AddCut(cutKTOFMatch); if (!scheme.IsNull()) scheme += "&"; scheme += Form("(%s|(!%s))",cutKTOF->GetName(),cutKTOFMatch->GetName()); } } if (useEta) { Printf("Adding ETA ..."); AliRsnValueDaughter *valEta = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta); AliRsnCutValue *cutEta = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),etaMin,etaMax); cutEta->SetTargetType(AliRsnTarget::kDaughter); cutEta->SetValueObj(valEta); cuts->AddCut(cutEta); if (!scheme.IsNull()) scheme += "&"; scheme += cutEta->GetName(); } if (useTrackPtCut) { Printf("Adding Pt min=%.3f max=%.3f ...",trackPtMin,trackPtMax); AliRsnValueDaughter *valTrackPt = new AliRsnValueDaughter(Form("val%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kPt); AliRsnCutValue *cutTrackPt = new AliRsnCutValue(Form("cut%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),trackPtMin,trackPtMax); cutTrackPt->SetTargetType(AliRsnTarget::kDaughter); cutTrackPt->SetValueObj(valTrackPt); cuts->AddCut(cutTrackPt); if (!scheme.IsNull()) scheme += "&"; scheme += cutTrackPt->GetName(); } if (useNclTPC) { Printf("Adding NclTPC >= %i",NclTPC); AliRsnValueDaughter *valNclTPC = new AliRsnValueDaughter(Form("val%sNclTPC%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kNTPCclusters); AliRsnCutValue *cutNclTPC = new AliRsnCutValue(Form("cut%sNclTPC%s",AliPID::ParticleName(type1),opt.Data()),NclTPC-0.1,1000.); cutNclTPC->SetTargetType(AliRsnTarget::kDaughter); cutNclTPC->SetValueObj(valNclTPC); cuts->AddCut(cutNclTPC); if (!scheme.IsNull()) scheme += "&"; scheme += cutNclTPC->GetName(); } if (usePDG) { Printf("Adding PDG ..."); AliRsnCutPID *cutPDG = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE); cuts->AddCut(cutPDG); if (!scheme.IsNull()) scheme += "&"; scheme += cutPDG->GetName(); } Printf ("CUT Scheme is '%s'",scheme.Data()); cuts->SetCutScheme(scheme.Data()); if (opt.Contains("mon")) { AddMonitorOutput(cuts->GetMonitorOutput(),opt); } if (isRsnMini) { AliRsnMiniAnalysisTask *taskRsnMini = (AliRsnMiniAnalysisTask *)task; if (taskRsnMini) { taskRsnMini->AddTrackCuts(cuts); } } else { AliRsnDaughterSelector *sel = rsnIH->GetSelector(); // sel->SetLabelCheck(kFALSE); sel->Add(cuts, kTRUE); if (isRsnDev>=0 && opt.Contains("pairPID")) { AliRsnActPostDaughterSelection *pairPID = new AliRsnActPostDaughterSelection(); pairPID->SetID(0); const char *fn="rsnRange.txt"; if (!gSystem->AccessPathName(fn)) { TString minStr = gSystem->GetFromPipe(TString::Format("head -n 1 %s").Data()); TString maxStr = gSystem->GetFromPipe(TString::Format("tail -n 1 %s").Data()); pairPID->SetMass(minStr.Atof(),maxStr.Atof()); } else { // pairPID->SetMass(1.01,1.03); pairPID->SetMass(1.015,1.025); pairPID->SetMass(1.019,1.021); pairPID->SetMass(1.0195,1.0205); pairPID->SetMass(1.1000,1.1005); // pairPID->SetMass(1.1005,1.1010); } sel->AddAction(pairPID); } } return numberOfCuts; }
// // *** Configuration script for phi->KK analysis with 2010 runs *** // // A configuration script for RSN package needs to define the followings: // // (1) decay tree of each resonance to be studied, which is needed to select // true pairs and to assign the right mass to all candidate daughters // (2) cuts at all levels: single daughters, tracks, events // (3) output objects: histograms or trees // Bool_t ConfigKStar ( AliRsnMiniAnalysisTask *task, Bool_t isMC, const char *suffix, AliRsnCutSet *cutsPair ) { // manage suffix if (strlen(suffix) > 0) suffix = Form("_%s", suffix); // // -- Define track cuts ------------------------------------------------------------------------- // // integrated pion cut AliRsnCutDaughterKStar2010PP *cutPi = new AliRsnCutDaughterKStar2010PP("cutPionForKStar", AliPID::kPion); // cut set AliRsnCutSet *cutSetPi = new AliRsnCutSet("setPionForKStar", AliRsnTarget::kDaughter); cutSetPi->AddCut(cutPi); cutSetPi->SetCutScheme(cutPi->GetName()); // add to task Int_t iCutPi = task->AddTrackCuts(cutSetPi); // integrated kaon cut AliRsnCutDaughterKStar2010PP *cutK = new AliRsnCutDaughterKStar2010PP("cutKaonForKStar", AliPID::kKaon); // cut set AliRsnCutSet *cutSetK = new AliRsnCutSet("setKaonForKStar", AliRsnTarget::kDaughter); cutSetK->AddCut(cutK); cutSetK->SetCutScheme(cutK->GetName()); // add to task Int_t iCutK = task->AddTrackCuts(cutSetK); // // -- Values ------------------------------------------------------------------------------------ // /* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE); /* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE); /* transv. momentum */ Int_t ptID = task->CreateValue(AliRsnMiniValue::kPt, kFALSE); /* centrality */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE); // // -- Create all needed outputs ----------------------------------------------------------------- // // use an array for more compact writing, which are different on mixing and charges // [0] = unlike // [1] = mixing // [2] = like ++ // [3] = like -- Bool_t use [10] = { 1 , 1 , 1 , 1 , 1 , 1 , isMC , isMC , isMC , isMC }; Bool_t useIM [10] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 }; TString name [10] = {"Unlike1", "Unlike2", "Mixing1", "Mixing2", "LikePP", "LikeMM", "Trues1", "Trues2", "Res1" , "Res2" }; TString comp [10] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" , "TRUE" , "TRUE" }; TString output [10] = {"HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" }; Char_t charge1 [10] = {'+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' }; Char_t charge2 [10] = {'-' , '+' , '-' , '+' , '+' , '-' , '-' , '+' , '-' , '+' }; Int_t cutID1 [10] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK }; Int_t cutID2 [10] = { iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi }; for (Int_t i = 0; i < 10; i++) { if (!use[i]) continue; // create output AliRsnMiniOutput *out = task->CreateOutput(Form("kstar_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data()); // selection settings out->SetCutID(0, cutID1[i]); out->SetCutID(1, cutID2[i]); out->SetDaughter(0, AliRsnDaughter::kKaon); out->SetDaughter(1, AliRsnDaughter::kPion); out->SetCharge(0, charge1[i]); out->SetCharge(1, charge2[i]); out->SetMotherPDG(313); out->SetMotherMass(0.896); // pair cuts out->SetPairCuts(cutsPair); // axis X: invmass (or resolution) if (useIM[i]) out->AddAxis(imID, 90, 0.6, 1.5); else out->AddAxis(resID, 200, -0.02, 0.02); // axis Y: transverse momentum out->AddAxis(ptID, 100, 0.0, 10.0); } return kTRUE; }
AliRsnMiniAnalysisTask * AddTaskKsPP5TeV_PID ( Bool_t isMC = kFALSE, Bool_t isPP = kTRUE, TString outNameSuffix = "tpc2stof3sveto", Int_t evtCutSetID = 0, Int_t pairCutSetID = 0, Int_t mixingConfigID = 0, Int_t aodFilterBit = 5, Int_t customQualityCutsID = -1, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutPiCandidate = AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate = AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s, Float_t nsigmaPi = 2.0, Float_t nsigmaKa = 2.0, Bool_t enableMonitor = kTRUE, Bool_t IsMcTrueOnly = kFALSE, TString monitorOpt = "NoSIGN", Bool_t useMixLS = 0, Bool_t checkReflex = 0, AliRsnMiniValue::EType yaxisvar = AliRsnMiniValue::kPt ) { //------------------------------------------- // event cuts //------------------------------------------- UInt_t triggerMask = AliVEvent::kINT7;//A Khuntia // if(isMC && (evtCutSetID==eventCutSet::kNoEvtSel || evtCutSetID==eventCutSet::kSpecial3)) triggerMask=AliVEvent::kAny; Bool_t rejectPileUp = kTRUE; // Double_t vtxZcut = 10.0; //cm, default cut on vtx z Int_t MultBins=aodFilterBit/100; if (evtCutSetID==eventCutSet::kDefaultVtx12){vtxZcut = 12.0;} //cm if (evtCutSetID==eventCutSet::kDefaultVtx8){vtxZcut = 8.0;} //cm if (evtCutSetID==eventCutSet::kDefaultVtx5){vtxZcut = 5.0;}//cm if (evtCutSetID==eventCutSet::kNoPileUpCut){rejectPileUp=kFALSE;}//cm if(evtCutSetID==eventCutSet::kSpecial2) vtxZcut=1.e6;//off if(!isPP || isMC || MultBins) rejectPileUp=kFALSE; //------------------------------------------- //pair cuts //------------------------------------------- Double_t minYlab = -0.5; Double_t maxYlab = 0.5; if (pairCutSetID==pairYCutSet::kCentral) { //|y_cm|<0.3 minYlab = -0.3; maxYlab = 0.3; } //------------------------------------------- //mixing settings //------------------------------------------- Int_t nmix = 0; Float_t maxDiffVzMix = 1.0; Float_t maxDiffMultMix = 10.0; if (mixingConfigID == eventMixConfig::kMixDefault) { nmix = 10;} if (mixingConfigID == eventMixConfig::k5Evts) {nmix = 5;} if (mixingConfigID == eventMixConfig::k5Cent) {maxDiffMultMix = 5;} if(mixingConfigID==eventMixConfig::k5Evts5Cent){nmix=5; maxDiffMultMix=5;} // // -- INITIALIZATION ---------------------------------------------------------------------------- // retrieve analysis manager // AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); if (!mgr) { ::Error("AddAnalysisTaskTOFKStar", "No analysis manager to connect to."); return NULL; } // create the task and configure TString taskName = Form("TOFKStar%s%s_%i%i", (isPP? "pp" : "PbPb"), (isMC ? "MC" : "Data"), (Int_t)cutPiCandidate,(Int_t)cutKaCandidate ); AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), isMC); //task->UseESDTriggerMask(triggerMask); //ESD //task->SelectCollisionCandidates(triggerMask); //AOD if(evtCutSetID!=eventCutSet::kNoEvtSel && evtCutSetID!=eventCutSet::kSpecial3) task->SelectCollisionCandidates(triggerMask); //AOD if(isPP){ if(MultBins==1) task->UseMultiplicity("AliMultSelection_V0M"); else if(MultBins==2) task->UseMultiplicity("AliMultSelection_RefMult08"); else task->UseMultiplicity("QUALITY"); }else task->UseCentrality("V0M"); // set event mixing options task->UseContinuousMix(); //task->UseBinnedMix(); task->SetNMix(nmix); task->SetMaxDiffVz(maxDiffVzMix); task->SetMaxDiffMult(maxDiffMultMix); ::Info("AddTaskKsPP5TeV_PID", Form("Event mixing configuration: \n events to mix = %i \n max diff. vtxZ = cm %5.3f \n max diff multi = %5.3f", nmix, maxDiffVzMix, maxDiffMultMix)); mgr->AddTask(task); // // cut on primary vertex: // - 2nd argument --> |Vz| range // - 3rd argument --> minimum required number of contributors to vtx // - 4th argument --> tells if TPC stand-alone vertexes must be accepted AliRsnCutPrimaryVertex* cutVertex=0; if(evtCutSetID!=eventCutSet::kSpecial1 && evtCutSetID!=eventCutSet::kNoEvtSel && (!MultBins || fabs(vtxZcut-10.)>1.e-10)){ cutVertex=new AliRsnCutPrimaryVertex("cutVertex",vtxZcut,0,kFALSE); if(!MultBins && evtCutSetID!=eventCutSet::kSpecial3){ cutVertex->SetCheckZResolutionSPD(); cutVertex->SetCheckDispersionSPD(); cutVertex->SetCheckZDifferenceSPDTrack(); } if (evtCutSetID==eventCutSet::kSpecial3) cutVertex->SetCheckGeneratedVertexZ(); } ///////----------AKhuntia----------////// AliRsnCutEventUtils* cutEventUtils=0; if(evtCutSetID!=eventCutSet::kNoEvtSel && evtCutSetID!=eventCutSet::kSpecial3){ cutEventUtils=new AliRsnCutEventUtils("cutEventUtils",kTRUE,rejectPileUp); if(!MultBins){ cutEventUtils->SetCheckIncompleteDAQ(); cutEventUtils->SetCheckSPDClusterVsTrackletBG(); }else{ //cutEventUtils->SetCheckInelGt0SPDtracklets(); cutEventUtils->SetRemovePileUppA2013(kFALSE); cutEventUtils->SetCheckAcceptedMultSelection(); } } if(isPP && (!isMC) && cutVertex){ cutVertex->SetCheckPileUp(rejectPileUp);// set the check for pileup ::Info("AddTaskKsPP5TeV_PID", Form(":::::::::::::::::: Pile-up rejection mode: %s", (rejectPileUp)?"ON":"OFF")); } //------------------------------------ // define and fill cut set for event cut AliRsnCutSet* eventCuts=0; if(cutEventUtils || cutVertex){ eventCuts=new AliRsnCutSet("eventCuts",AliRsnTarget::kEvent); if(cutEventUtils && cutVertex){ eventCuts->AddCut(cutEventUtils); eventCuts->AddCut(cutVertex); eventCuts->SetCutScheme(Form("%s&%s",cutEventUtils->GetName(),cutVertex->GetName())); }else if(cutEventUtils && !cutVertex){ eventCuts->AddCut(cutEventUtils); eventCuts->SetCutScheme(Form("%s",cutEventUtils->GetName())); }else if(!cutEventUtils && cutVertex){ eventCuts->AddCut(cutVertex); eventCuts->SetCutScheme(Form("%s",cutVertex->GetName())); } task->SetEventCuts(eventCuts); } // -- EVENT-ONLY COMPUTATIONS ------------------------------------------------------------------- // //vertex Int_t vtxID=task->CreateValue(AliRsnMiniValue::kVz,kFALSE); AliRsnMiniOutput* outVtx=task->CreateOutput("eventVtx","HIST","EVENT"); outVtx->AddAxis(vtxID,240,-12.0,12.0); //multiplicity or centrality Int_t multID=task->CreateValue(AliRsnMiniValue::kMult,kFALSE); AliRsnMiniOutput* outMult=task->CreateOutput("eventMult","HIST","EVENT"); if(isPP && !MultBins) outMult->AddAxis(multID,400,0.5,400.5); else outMult->AddAxis(multID,110,0.,110.); TH2F* hvz=new TH2F("hVzVsCent","",110,0.,110., 240,-12.0,12.0); task->SetEventQAHist("vz",hvz);//plugs this histogram into the fHAEventVz data member TH2F* hmc=new TH2F("MultiVsCent","", 110,0.,110., 400,0.5,400.5); hmc->GetYaxis()->SetTitle("QUALITY"); task->SetEventQAHist("multicent",hmc);//plugs this histogram into the fHAEventMultiCent data member // // -- PAIR CUTS (common to all resonances) ------------------------------------------------------ // AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange); cutY->SetRangeD(minYlab, maxYlab); AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother); cutsPair->AddCut(cutY); cutsPair->SetCutScheme(cutY->GetName()); // // -- CONFIG ANALYSIS -------------------------------------------------------------------------- // gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/ConfigKsPP5TeV_PID.C"); //gROOT->LoadMacro("ConfigKStarPP8TeV_PID.C"); if (!ConfigKsPP5TeV_PID(task, isMC, isPP, "", cutsPair, aodFilterBit, customQualityCutsID, cutPiCandidate, cutKaCandidate, nsigmaPi, nsigmaKa, enableMonitor, isMC&IsMcTrueOnly, monitorOpt.Data(), useMixLS, isMC&checkReflex, yaxisvar)) return 0x0; // // -- CONTAINERS -------------------------------------------------------------------------------- // TString outputFileName = AliAnalysisManager::GetCommonFileName(); // outputFileName += ":Rsn"; Printf("AddAnalysisTaskTOFKStar - Set OutputFileName : \n %s\n", outputFileName.Data() ); AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnOut_%s",outNameSuffix.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, outputFileName); mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer()); mgr->ConnectOutput(task, 1, output); return task; }
// // Test config macro for RSN package. // It configures: // 1) a monitor for all tracks passing quality cuts // 2) a monitor for all tracks passing quality + PID cuts // 3) an unlike-sign invariant-mass + pt distribution for K+K- pairs // Bool_t RsnConfigPhiKaonTest ( AliRsnAnalysisTask *task, Bool_t isMC ) { if (!task) { ::Error("RsnConfigPhiKaonTest.C", "NULL task"); return kFALSE; } const char *suffix = "test"; // ---------------------------------------------------------------------------------------------- // -- DEFINITIONS ------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------- // daughter definition for monitor loops // since it is intended to loop over all 'track' like objects (in the sense that we exclude V0s and cascades), // we initialize it using the constructor that requires an AliRsnDaughter::EType and a charge, but since // we want to loop over both charges, we set it to anything which is not '+' '-' or '0', which are tokens for // selecting only positive, only negative or only neutral AliRsnDaughterDef *tracks = new AliRsnDaughterDef(AliRsnDaughter::kTrack, 0); // definition of pair decay tree for phi resonance // here we *must* specify a particle species and a charge, in order to check the decay tree // last arguments are the PDG code and nominal mass of the resonance, which are needed when // one wants to select true pairs only and/or he wants to compute rapidity or Mt AliRsnPairDef *pairDef = new AliRsnPairDef(AliRsnDaughter::kKaon, '+', AliRsnDaughter::kKaon, '-', 333, 1.019455); // definition of loop objects: // (a) 1 monitor for all tracks passing quality cuts // (b) 1 monitor for all tracks passing quality+PID cuts // (c) 1 pair filled with all tracks passing same cuts as (b) // (d) 1 pair like (c) but for mixing // (e) 1 pair like (c) but with true pairs only // NOTE: (c) and (d) are instantiated with same settings, they will be made // different after some settings done in second moment AliRsnLoopDaughter *loopQuality = new AliRsnLoopDaughter(Form("%s_mon_quality", suffix), 0, tracks); AliRsnLoopDaughter *loopPID = new AliRsnLoopDaughter(Form("%s_mon_pid" , suffix), 0, tracks); AliRsnLoopPair *loopPhi = new AliRsnLoopPair (Form("%s_unlike" , suffix), pairDef); AliRsnLoopPair *loopPhiMix = new AliRsnLoopPair (Form("%s_unlike" , suffix), pairDef); AliRsnLoopPair *loopPhiTrue = new AliRsnLoopPair (Form("%s_trues" , suffix), pairDef); // set additional option for true pairs (slot [0]) loopPhiTrue->SetOnlyTrue(kTRUE); loopPhiTrue->SetCheckDecay(kTRUE); // set mixing options loopPhi ->SetMixed(kFALSE); loopPhiMix ->SetMixed(kTRUE); loopPhiTrue->SetMixed(kFALSE); // assign the ID of the entry lists to be used by each pair to get selected daughters // in our case, the AliRsnInputHandler contains only one list for selecting kaons Int_t idQuality, idPID; AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); AliMultiInputEventHandler *multi = dynamic_cast<AliMultiInputEventHandler*>(mgr->GetInputEventHandler()); if (!multi) { myError("Needed a multi input handler!"); return kFALSE; } TObjArray *array = multi->InputEventHandlers(); AliRsnInputHandler *rsn = (AliRsnInputHandler*)array->FindObject("rsnInputHandler"); if (!rsn) { myError("Needed an RSN event handler"); return kFALSE; } AliRsnDaughterSelector *sel = rsn->GetSelector(); idQuality = sel->GetID("qualityTPC", kTRUE); idPID = sel->GetID("kaonTPC", kTRUE); if (idQuality < 0 || idPID < 0) { myError("List problems"); return kFALSE; } loopQuality->SetListID(idQuality); loopPID ->SetListID(idPID); loopPhi ->SetListID(0, idPID); loopPhi ->SetListID(1, idPID); loopPhiMix ->SetListID(0, idPID); loopPhiMix ->SetListID(1, idPID); loopPhiTrue->SetListID(0, idPID); loopPhiTrue->SetListID(1, idPID); // ---------------------------------------------------------------------------------------------- // -- EVENT CUTS -------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------- // primary vertex: // - 2nd argument --> |Vz| range // - 3rd argument --> minimum required number of contributors // - 4th argument --> tells if TPC stand-alone vertexes must be accepted // we switch on the check for pileup AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE); cutVertex->SetCheckPileUp(kTRUE); // primary vertex is always used AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent); eventCuts->AddCut(cutVertex); eventCuts->SetCutScheme(cutVertex->GetName()); // add the event cuts to all loops loopQuality->SetEventCuts(eventCuts); loopPID ->SetEventCuts(eventCuts); loopPhi ->SetEventCuts(eventCuts); loopPhi ->SetEventCuts(eventCuts); loopPhiMix ->SetEventCuts(eventCuts); loopPhiMix ->SetEventCuts(eventCuts); loopPhiTrue->SetEventCuts(eventCuts); loopPhiTrue->SetEventCuts(eventCuts); // ---------------------------------------------------------------------------------------------- // -- PAIR CUTS --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------- // for pairs we define a rapidity windows, defined through a cut // --> NOTE: it needs a support AliRsnPairDef from which it takes the mass AliRsnValueStd *valRapidity = new AliRsnValueStd("valY", AliRsnValueStd::kPairY); AliRsnCutValue *cutRapidity = new AliRsnCutValue("cutY", -0.5, 0.5, isMC); valRapidity->SetSupportObject(pairDef); cutRapidity->SetValueObj(valRapidity); // cut set AliRsnCutSet *pairCuts = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother); pairCuts->AddCut(cutRapidity); pairCuts->SetCutScheme(cutRapidity->GetName()); // add cut to pair loops only loopPhi ->SetPairCuts(pairCuts); loopPhi ->SetPairCuts(pairCuts); loopPhiMix ->SetPairCuts(pairCuts); loopPhiMix ->SetPairCuts(pairCuts); loopPhiTrue->SetPairCuts(pairCuts); loopPhiTrue->SetPairCuts(pairCuts); // ---------------------------------------------------------------------------------------------- // -- COMPUTED VALUES & OUTPUTS ----------------------------------------------------------------- // ---------------------------------------------------------------------------------------------- AliRsnValueStd *axisIM = new AliRsnValueStd("IM" , AliRsnValueStd::kPairInvMass , 0.9, 1.4, 0.001); AliRsnValueStd *axisPt = new AliRsnValueStd("PT" , AliRsnValueStd::kPairPt , 0.0, 5.0, 0.1 ); AliRsnValueStd *axisMomTPC = new AliRsnValueStd("pTPC", AliRsnValueStd::kTrackPtpc , 0.0, 5.0, 0.01 ); AliRsnValueStd *axisSigTPC = new AliRsnValueStd("sTPC", AliRsnValueStd::kTrackTPCsignal, 0.0, 500.0, 2.0 ); // output for monitors: // 2D histogram with TPC signal vs TPC momentum AliRsnListOutput *outMonitor = new AliRsnListOutput("mon", AliRsnListOutput::kHistoDefault); outMonitor->AddValue(axisMomTPC); outMonitor->AddValue(axisSigTPC); // output for pairs: // 2D histogram with inv.mass vs pt AliRsnListOutput *outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoDefault); outPair->AddValue(axisIM); outPair->AddValue(axisPt); // add outputs to loops loopQuality->AddOutput(outMonitor); loopPID ->AddOutput(outMonitor); loopPhi ->AddOutput(outPair); loopPhiMix ->AddOutput(outPair); loopPhiTrue->AddOutput(outPair); // ---------------------------------------------------------------------------------------------- // -- CONCLUSION -------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------- task->Add(loopQuality); task->Add(loopPID ); task->Add(loopPhi ); task->Add(loopPhiMix ); task->Add(loopPhiTrue); return kTRUE; }
// // *** Configuration script for phi->KK analysis with 2010 runs *** // // A configuration script for RSN package needs to define the followings: // // (1) decay tree of each resonance to be studied, which is needed to select // true pairs and to assign the right mass to all candidate daughters // (2) cuts at all levels: single daughters, tracks, events // (3) output objects: histograms or trees // Bool_t ConfigPhiPbPbTPC ( AliRsnMiniAnalysisTask *task, Bool_t isMC, Bool_t isESD, const char *suffix, AliRsnCutSet *cutsPair ) { // manage suffix if (strlen(suffix) > 0) suffix = Form("_%s", suffix); // // -- Define track cuts ------------------------------------------------------------------------- // // BB parameterization depends on data sample (MC, data) Double_t bbPar[5]; if (isMC) { bbPar[0] = 2.15898 / 50.0; bbPar[1] = 1.75295E1; bbPar[2] = 3.40030E-9; bbPar[3] = 1.96178; bbPar[4] = 3.91720; } else { bbPar[0] = 1.41543 / 50.0; bbPar[1] = 2.63394E1; bbPar[2] = 5.0411E-11; bbPar[3] = 2.12543; bbPar[4] = 4.88663; } // standard kaon cut AliRsnCutKaonForPhi2010 *cut = new AliRsnCutKaonForPhi2010(Form("cut%s", suffix), 3.0, 3.0, 0.8); // setup (set manually the TPC PID) cut->SetMode(AliRsnCutKaonForPhi2010::kOnlyTPC); cut->InitMyPID(isMC, isESD); cut->MyPID()->GetTPCResponse().SetBetheBlochParameters(bbPar[0], bbPar[1], bbPar[2], bbPar[3], bbPar[4]); // cut set AliRsnCutSet *cutSet = new AliRsnCutSet(Form("set%s", suffix), AliRsnTarget::kDaughter); cutSet->AddCut(cut); cutSet->SetCutScheme(cut->GetName()); // add to task Int_t icut = task->AddTrackCuts(cutSet); ::Info("Config", "Cut ID = %d", icut); // // -- Values ------------------------------------------------------------------------------------ // /* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE); /* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE); /* transv. momentum */ Int_t ptID = task->CreateValue(AliRsnMiniValue::kPt, kFALSE); /* centrality */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE); // // -- Create all needed outputs ----------------------------------------------------------------- // // use an array for more compact writing, which are different on mixing and charges // [0] = unlike // [1] = mixing // [2] = like ++ // [3] = like -- Bool_t use [6] = { 1 , 0 , 0 , 0 , isMC , isMC }; Bool_t useIM [6] = { 1 , 1 , 1 , 1 , 1 , 0 }; TString name [6] = {"Unlike", "Mixing", "LikePP", "LikeMM", "Trues" , "Res" }; TString comp [6] = {"PAIR" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" }; TString output [6] = {"SPARSE", "SPARSE", "SPARSE", "SPARSE", "SPARSE", "SPARSE" }; Char_t charge1 [6] = {'+' , '+' , '+' , '-' , '+' , '+' }; Char_t charge2 [6] = {'-' , '-' , '+' , '-' , '-' , '-' }; Int_t cutID [6] = { icut , icut , icut , icut , icut , icut }; for (Int_t i = 0; i < 6; i++) { if (!use[i]) continue; // create output AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data()); // selection settings out->SetCutID(0, cutID[i]); out->SetCutID(1, cutID[i]); out->SetDaughter(0, AliRsnDaughter::kKaon); out->SetDaughter(1, AliRsnDaughter::kKaon); out->SetCharge(0, charge1[i]); out->SetCharge(1, charge2[i]); out->SetMotherPDG(333); out->SetMotherMass(1.019455); // pair cuts out->SetPairCuts(cutsPair); // axis X: invmass (or resolution) if (useIM) out->AddAxis(imID, 500, 0.9, 1.4); else out->AddAxis(resID, 200, -0.02, 0.02); // axis Y: transverse momentum out->AddAxis(ptID, 100, 0.0, 10.0); // axis Z: centrality out->AddAxis(centID, 100, 0.0, 100.0); } return kTRUE; }
// // *** Configuration script for K*+-->K0Short-Pi analysis *** // // A configuration script for RSN package needs to define the followings: // // (1) decay tree of each resonance to be studied, which is needed to select // true pairs and to assign the right mass to all candidate daughters // (2) cuts at all levels: single daughters, tracks, events // (3) output objects: histograms or trees // Bool_t ConfigKStarPlusMinus ( AliRsnMiniAnalysisTask *task, Int_t collSyst, Bool_t isMC, Float_t piPIDCut, Float_t pPIDCut, Int_t aodFilterBit, Float_t trackDCAcut, Float_t massTol, Float_t lambdaDCA, Float_t lambdaCosPoinAn, Float_t lambdaDaughDCA, Int_t NTPCcluster, const char *suffix, AliRsnCutSet *cutsPair ) { // manage suffix if (strlen(suffix) > 0) suffix = Form("_%s", suffix); ///////////////////////////////////////////////////// // selections for the pion from the decay of KStarPlusMinus* ///////////////////////////////////////////////////// // AliRsnCutDaughterSigmaStar2010PP *cutPi = new AliRsnCutDaughterSigmaStar2010PP("cutPionForKStarPlusMinus", AliPID::kPion); cutPi->SetPIDCut(piPIDCut); // fPIDCut used in IsSelected() after the call to cutQuality AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutPi->CutQuality(); //cutQuality->SetDefaults2011(); cutQuality->SetDefaults2010(0,1); // 1st par. not default (0 -> use TPC clusters). 2nd par. default (-> standard Pt and eta range) // SetDefaults2010 contains the following selections: // SetPtRange(0.15, 1E+20); // SetEtaRange(-0.8, 0.8); // and from aliroot/master/src/ANALYSIS/ANALYSISalice/AliESDtrackCuts.cxx // AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(1,0) // esdTrackCuts->SetMinNClustersTPC(70); // esdTrackCuts->SetMaxChi2PerClusterTPC(4); // esdTrackCuts->SetAcceptKinkDaughters(kFALSE); // esdTrackCuts->SetRequireTPCRefit(kTRUE); // esdTrackCuts->SetRequireITSRefit(kTRUE); // esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny); // esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01"); // NB. With pt_min=0.15 (see above) -> DCAxy_max = 0.2560 // esdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36); // esdTrackCuts->SetMaxDCAToVertexZ(2); // esdTrackCuts->SetDCAToVertex2D(kFALSE); // esdTrackCuts->SetRequireSigmaToVertex(kFALSE); // esdTrackCuts->SetMaxChi2PerClusterITS(36); // AliRsnCutSet *cutSetPi = new AliRsnCutSet("setPionForKStarPlusMinus", AliRsnTarget::kDaughter); cutSetPi->AddCut(cutPi); cutSetPi->SetCutScheme(cutPi->GetName()); Int_t iCutPi = task->AddTrackCuts(cutSetPi); // ///////////////////////////////////////////////////////////// // selections for Lambda and for the daughters of Lambda ///////////////////////////////////////////////////////////// // // selections for the proton and pion daugthers of Lambda and AntiLambda AliESDtrackCuts *esdTrackCuts = new AliESDtrackCuts("qualityDaughterLambda"); esdTrackCuts->SetPtRange(0.15,1.E10); esdTrackCuts->SetEtaRange(-0.8,0.8); esdTrackCuts->SetRequireTPCRefit(); esdTrackCuts->SetAcceptKinkDaughters(0); // esdTrackCuts->SetMinNClustersTPC(NTPCcluster); esdTrackCuts->SetMaxChi2PerClusterTPC(4); esdTrackCuts->SetMinDCAToVertexXY(0.15); // ///////////////////////////////////////////////// // selections for Lambda AliRsnCutV0 *cutLambda = new AliRsnCutV0("cutLambda", kK0Short, AliPID::kPion, AliPID::kPion); cutLambda->SetPIDCutProton(pPIDCut); // PID for the proton daughter of Lambda cutLambda->SetPIDCutPion(piPIDCut); // PID for the pion daughter of Lambda cutLambda->SetESDtrackCuts(esdTrackCuts); // all the other selections (defined above) for proton and pion daughters of Lambda cutLambda->SetMaxDaughtersDCA(lambdaDaughDCA); cutLambda->SetMaxDCAVertex(lambdaDCA); cutLambda->SetMinCosPointingAngle(lambdaCosPoinAn); cutLambda->SetTolerance(massTol); cutLambda->SetMaxRapidity(0.5); // AliRsnCutSet *cutSetLambda = new AliRsnCutSet("setLambda", AliRsnTarget::kDaughter); cutSetLambda->AddCut(cutLambda); cutSetLambda->SetCutScheme(cutLambda->GetName()); Int_t iCutLambda = task->AddTrackCuts(cutSetLambda); // //###################################################################################################### // // -- Values ------------------------------------------------------------------------------------ // /* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE); /* transv. momentum */ Int_t ptID = task->CreateValue(AliRsnMiniValue::kPt, kFALSE); /* centrality */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE); // // -- Create all needed outputs ----------------------------------------------------------------- // // use an array for more compact writing, which are different on mixing and charges // [0] = unlike // [1] = mixing // [2] = like ++ // [3] = like -- Bool_t use [6] = {1 ,1 ,1 ,1 ,1 ,1 }; Bool_t useIM [6] = {1 ,1 ,1 ,1 ,1 ,1 }; TString name [6] = {"KStarPlusMinus","AKStarPlusMinus","KStarPlusMinusmix","AKStarPlusMinusmix","KStarPlusMinust","AKStarPlusMinust"}; TString comp [6] = {"PAIR" ,"PAIR" ,"MIX" ,"MIX" ,"TRUE" ,"TRUE" }; TString output [6] = {"HIST" ,"HIST" ,"HIST" ,"HIST" ,"HIST" ,"HIST" }; Char_t charge1 [6] = {'0' ,'0' ,'0' ,'0' ,'0' ,'0' }; Char_t charge2 [6] = {'+' ,'-' ,'+' ,'-' ,'+' ,'-' }; Int_t cutID1 [6] = { iCutLambda ,iCutLambda ,iCutLambda ,iCutLambda ,iCutLambda ,iCutLambda }; Int_t cutID2 [6] = { iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi }; Int_t ipdg [6] = {323 ,-323 ,323 ,-323 ,323 ,-323 }; Double_t mass [6] = { 0.89166 ,0.89166 ,0.89166 ,0.89166 ,0.89166 ,0.89166 }; for (Int_t i = 0; i < 6; i++) { if (!use[i]) continue; if (collSyst) output[i] = "SPARSE"; // create output AliRsnMiniOutput *out = task->CreateOutput(Form("sigmastar_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data()); // selection settings out->SetCutID(0, cutID1[i]); out->SetCutID(1, cutID2[i]); out->SetDaughter(0, AliRsnDaughter::kKaon0); out->SetDaughter(1, AliRsnDaughter::kPion); out->SetCharge(0, charge1[i]); out->SetCharge(1, charge2[i]); out->SetMotherPDG(ipdg[i]); out->SetMotherMass(mass[i]); // pair cuts out->SetPairCuts(cutsPair); // axis X: invmass if (useIM[i]) out->AddAxis(imID, 2000, 0, 2.0); // out->AddAxis(imID, 700, 1.2, 4.0); // axis Y: transverse momentum out->AddAxis(ptID, 100, 0.0, 10.0); //out->AddAxis(lambdaDCA, 10, 0.0, 1.0); if (collSyst) out->AddAxis(centID, 10, 0.0, 100.0); } AddMonitorOutput_PionPt(cutSetPi->GetMonitorOutput()); AddMonitorOutput_PionEta(cutSetPi->GetMonitorOutput()); AddMonitorOutput_PionDCAxy(cutSetPi->GetMonitorOutput()); AddMonitorOutput_PionDCAz(cutSetPi->GetMonitorOutput()); AddMonitorOutput_PionPIDCut(cutSetPi->GetMonitorOutput()); AddMonitorOutput_PionNTPC(cutSetPi->GetMonitorOutput()); AddMonitorOutput_PionTPCchi2(cutSetPi->GetMonitorOutput()); // AddMonitorOutput_LambdaP(cutSetLambda->GetMonitorOutput()); AddMonitorOutput_LambdaPt(cutSetLambda->GetMonitorOutput()); AddMonitorOutput_LambdaNegDaughPt(cutSetLambda->GetMonitorOutput()); AddMonitorOutput_LambdaPosDaughPt(cutSetLambda->GetMonitorOutput()); AddMonitorOutput_LambdaMass(cutSetLambda->GetMonitorOutput()); AddMonitorOutput_LambdaDCA(cutSetLambda->GetMonitorOutput()); AddMonitorOutput_LambdaRadius(cutSetLambda->GetMonitorOutput()); AddMonitorOutput_LambdaDaughterDCA(cutSetLambda->GetMonitorOutput()); AddMonitorOutput_LambdaCosPointAngle(cutSetLambda->GetMonitorOutput()); // AddMonitorOutput_LambdaProtonPID(cutSetLambda->GetMonitorOutput()); AddMonitorOutput_LambdaPionPID(cutSetLambda->GetMonitorOutput()); if (isMC) { TString mode = "HIST"; if (collSyst) mode = "SPARSE"; // create output AliRsnMiniOutput *out = task->CreateOutput(Form("KStarPlusMinus_TrueMC%s", suffix), mode.Data(), "MOTHER"); // selection settings out->SetDaughter(0, AliRsnDaughter::kKaon0); out->SetDaughter(1, AliRsnDaughter::kPion); out->SetMotherPDG(323); out->SetMotherMass(0.89166); // pair cuts out->SetPairCuts(cutsPair); // binnings out->AddAxis(imID, 2000, 0.0, 2.0); out->AddAxis(ptID, 100, 0.0, 10.0); //out->AddAxis(lambdaDCA, 10, 0.0, 1.0); if (collSyst) out->AddAxis(centID, 10, 0.0, 100.0); // create output AliRsnMiniOutput *out = task->CreateOutput(Form("AKStarPlusMinus_TrueMC%s", suffix), mode.Data(), "MOTHER"); // selection settings out->SetDaughter(0, AliRsnDaughter::kKaon0); out->SetDaughter(1, AliRsnDaughter::kPion); out->SetMotherPDG(-323); out->SetMotherMass(0.89166); // pair cuts out->SetPairCuts(cutsPair); // binnings out->AddAxis(imID, 2000, 0.0, 2.0); out->AddAxis(ptID, 100, 0.0, 10.0); //out->AddAxis(lambdaDCA, 10, 0.0, 1.0); if (collSyst) out->AddAxis(centID, 10, 0.0, 100.0); } return kTRUE; }
Int_t AddRsnDaughterCutsRhoNsigma(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,Bool_t isRsnMini=kFALSE,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0) { if (!rsnIH) return 0; Bool_t valid = kTRUE; Int_t isPP = AliAnalysisManager::GetGlobalInt("rsnIsPP",valid); Bool_t usePPCut = kFALSE; if (isPP && (opt.Contains("usePP"))) usePPCut = kTRUE; // === USER HAS TO SET CORRECT NUMBER OF CUTS SETS ===== Int_t numberOfCuts = 1; //--------------------------------------------- // Define single cuts //--------------------------------------------- Printf("AddRsnDaughterCutsRho Option : %s",opt.Data()); Double_t nSigmaTPC=3.0; Double_t nSigmaTOF=3.0; Double_t etaRange=0.8; Bool_t useTPC_Pi=kFALSE; Bool_t useTOF_Pi=kFALSE; if (opt.Contains("qualityonly")) { useTPC_Pi=kFALSE; useTOF_Pi=kFALSE; } else if (!opt.Contains("nsig")) { useTPC_Pi=kTRUE; useTOF_Pi=kTRUE; } if (opt.Contains("PiTPCnsig")) useTPC_Pi=kTRUE; if (opt.Contains("PiTOFnsig")) useTOF_Pi=kTRUE; if (opt.Contains("PiTPCnsig10")) nSigmaTPC = 1.0; if (opt.Contains("PiTPCnsig15")) nSigmaTPC = 1.5; if (opt.Contains("PiTPCnsig20")) nSigmaTPC = 2.0; if (opt.Contains("PiTPCnsig25")) nSigmaTPC = 2.5; if (opt.Contains("PiTPCnsig30")) nSigmaTPC = 3.0; if (opt.Contains("PiTOFnsig10")) nSigmaTOF = 1.0; if (opt.Contains("PiTOFnsig15")) nSigmaTOF = 1.5; if (opt.Contains("PiTOFnsig20")) nSigmaTOF = 2.0; if (opt.Contains("PiTOFnsig25")) nSigmaTOF = 2.5; if (opt.Contains("PiTOFnsig30")) nSigmaTOF = 3.0; Bool_t usePDG=kFALSE; if (opt.Contains("pdg")) { Printf("Using PDG"); usePDG = kTRUE; } Bool_t useEta = kFALSE; if (opt.Contains("eta")) { Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange); useEta = kTRUE; } //--------------------------------------------- // Combine cuts //--------------------------------------------- TString cutname = "Pi_Rho"; if (!opt.IsNull()) cutname += Form("_%s",opt.Data()); AliRsnCutSet *cuts = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter); TString scheme=""; AliRsnCutTrackQuality *qualityCut = new AliRsnCutTrackQuality("cutQuatityPi"); qualityCut->SetDefaults2010(); cuts->AddCut(qualityCut); if (!scheme.IsNull()) scheme += "&"; scheme += qualityCut->GetName(); if (useTPC_Pi) { AliRsnCutPIDNSigma *cutPiTPC = new AliRsnCutPIDNSigma("cutPIDNSigmaTPCPi",AliPID::kPion,AliRsnCutPIDNSigma::kTPC); cutPiTPC->SinglePIDRange(nSigmaTPC); cuts->AddCut(cutPiTPC); if (!scheme.IsNull()) scheme += "&"; scheme += cutPiTPC->GetName(); } if (useTOF_Pi) { AliRsnCutPIDNSigma *cutPiTOF = new AliRsnCutPIDNSigma("cutPIDNSigmaTOFPi",AliPID::kPion,AliRsnCutPIDNSigma::kTOF); cutPiTOF->SinglePIDRange(nSigmaTOF); cuts->AddCut(cutPiTOF); if (!scheme.IsNull()) scheme += "&"; scheme += cutPiTOF->GetName(); } if (useEta) { Printf("Adding ETA ..."); AliRsnValueDaughter *valEta = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta); AliRsnCutValue *cutEta = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange); cutEta->SetTargetType(AliRsnTarget::kDaughter); cutEta->SetValueObj(valEta); cuts->AddCut(cutEta); if (!scheme.IsNull()) scheme += "&"; scheme += cutEta->GetName(); } if (usePDG) { Printf("Adding PDG ..."); AliRsnCutPID *cutPDG = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE); cuts->AddCut(cutPDG); if (!scheme.IsNull()) scheme += "&"; scheme += cutPDG->GetName(); } Printf ("CUT Scheme is '%s'",scheme.Data()); cuts->SetCutScheme(scheme.Data()); if (opt.Contains("mon")) { AddMonitorOutput(cuts->GetMonitorOutput(),opt); } if (isRsnMini) { AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task); if (taskRsnMini) { taskRsnMini->AddTrackCuts(cuts); } } else { AliRsnDaughterSelector *sel = rsnIH->GetSelector(); // sel->SetLabelCheck(kFALSE); sel->Add(cuts, kTRUE); } return numberOfCuts; }
Bool_t ConfigTPCanalysisKStarTest ( AliRsnMiniAnalysisTask *task, Bool_t isMC, Bool_t isPP, const char *suffix, AliRsnCutSet *cutsPair, Float_t nsigmaPi = 2.0, Float_t nsigmaKa = 2.0, Bool_t enableMonitor = kTRUE, Bool_t IsMcTrueOnly = kFALSE, Int_t Pdg = 313, TString optSys = "Default" ) { // manage suffix if (strlen(suffix) > 0) suffix = Form("_%s", suffix); TString opt = "PbPb"; TString schemePi=""; TString schemeK=""; TString cutnameK = "K_KS"; TString cutnamePi = "Pi_KS"; if (!opt.IsNull()) cutnameK += Form("_%s",opt.Data()); if (!opt.IsNull()) cutnamePi += Form("_%s",opt.Data()); AliRsnCutSet * cutSetKaon = new AliRsnCutSet(cutnameK.Data(), AliRsnTarget::kDaughter); AliRsnCutSet * cutSetPion = new AliRsnCutSet(cutnamePi.Data(), AliRsnTarget::kDaughter); AliRsnCutTrackQuality *fQualityTrackCut = new AliRsnCutTrackQuality("AliRsnCutTrackQuality"); //Analysis Track cuts are implemented here AliESDtrackCuts * esdTrackCuts = MyTrackCuts(1, kTRUE,optSys.Data()); fQualityTrackCut->SetESDtrackCuts(esdTrackCuts); fQualityTrackCut->SetPtRange(0.15,30); fQualityTrackCut->SetEtaRange(-0.8,0.8); //PID selection cutSetKaon->AddCut(fQualityTrackCut); if (!schemeK.IsNull()) schemeK += "&"; schemeK += fQualityTrackCut->GetName(); cutSetPion->AddCut(fQualityTrackCut); if (!schemePi.IsNull()) schemePi += "&"; schemePi += fQualityTrackCut->GetName(); AliRsnCutPIDNSigma *cutPiTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCPi",AliPID::kPion,AliRsnCutPIDNSigma::kTPC); cutPiTPC->SinglePIDRange(nsigmaPi); cutSetPion->AddCut(cutPiTPC); if (!schemePi.IsNull()) schemePi += "&"; schemePi += cutPiTPC->GetName(); AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC); cutKTPC->SinglePIDRange(nsigmaKa); cutSetKaon->AddCut(cutKTPC); if (!schemeK.IsNull()) schemeK += "&"; schemeK += cutKTPC->GetName(); Printf ("CUT Scheme for KAON is '%s'",schemeK.Data()); Printf ("CUT Scheme for PION is '%s'",schemePi.Data()); cutSetPion->SetCutScheme(schemePi.Data()); cutSetKaon->SetCutScheme(schemeK.Data()); Int_t iCutPi = task->AddTrackCuts(cutSetPion); Int_t iCutK = task->AddTrackCuts(cutSetKaon); if(enableMonitor){ Printf("======== Monitoring cut AliRsnCutSetDaughterParticle enabled"); //gROOT->LoadMacro("$ALICE_ROOT/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C"); gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C"); AddMonitorOutput(isMC, cutSetPion->GetMonitorOutput()); AddMonitorOutput(isMC, cutSetKaon->GetMonitorOutput()); } // -- Values ------------------------------------------------------------------------------------ /* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE); /* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE); /* transv. momentum */ Int_t ptID = task->CreateValue(AliRsnMiniValue::kPt, kFALSE); /* centrality */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE); /* pseudorapidity */ Int_t etaID = task->CreateValue(AliRsnMiniValue::kEta, kFALSE); /* rapidity */ Int_t yID = task->CreateValue(AliRsnMiniValue::kY, kFALSE); // -- Create all needed outputs ----------------------------------------------------------------- // use an array for more compact writing, which are different on mixing and charges // [0] = unlike // [1] = mixing // [2] = like ++ // [3] = like -- Bool_t use [10] = { !IsMcTrueOnly, !IsMcTrueOnly, !IsMcTrueOnly, !IsMcTrueOnly , !IsMcTrueOnly, !IsMcTrueOnly, isMC , isMC , isMC , isMC }; Bool_t useIM [10] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 }; TString name [10] = {"UnlikePM", "UnlikeMP", "MixingPM", "MixingMP", "LikePP", "LikeMM", "TruesPM", "TruesMP", "ResPM" , "ResMP" }; TString comp [10] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" , "TRUE" , "TRUE" }; //TString output [10] = {"HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" }; TString output [10] = {"SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" }; Char_t charge1 [10] = {'+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' }; Char_t charge2 [10] = {'-' , '+' , '-' , '+' , '+' , '-' , '-' , '+' , '-' , '+' }; Int_t cutID1 [10] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK }; Int_t cutID2 [10] = { iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi }; for (Int_t i = 0; i < 10; i++) { if (!use[i]) continue; if(Pdg > 0) AliRsnMiniOutput *out = task->CreateOutput(Form("kstar1_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data()); if(Pdg < 0) AliRsnMiniOutput *out = task->CreateOutput(Form("kstar2_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data()); out->SetCutID(0, cutID1[i]); out->SetCutID(1, cutID2[i]); out->SetDaughter(0, AliRsnDaughter::kKaon); out->SetDaughter(1, AliRsnDaughter::kPion); out->SetCharge(0, charge1[i]); out->SetCharge(1, charge2[i]); out->SetMotherPDG(Pdg);//313 out->SetMotherMass(0.89594); out->SetPairCuts(cutsPair); // axis X: invmass (or resolution) if (useIM[i]) out->AddAxis(imID, 90, 0.6, 1.5); //else //out->AddAxis(resID, 200, -0.02, 0.02); // axis Y: transverse momentum out->AddAxis(ptID, 300, 0.0, 30.0); // axis Z: centrality-multiplicity if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); else out->AddAxis(centID, 400, 0.0, 400.0); // axis W: pseudorapidity // out->AddAxis(etaID, 20, -1.0, 1.0); // axis J: rapidity //out->AddAxis(yID, 32, -0.8, 0.8); } if (isMC){ // create output if(Pdg > 0) {AliRsnMiniOutput *outm = task->CreateOutput(Form("kstar_Mother1%s", suffix), "SPARSE", "MOTHER");} if(Pdg < 0) {AliRsnMiniOutput *outm = task->CreateOutput(Form("kstar_Mother2%s", suffix), "SPARSE", "MOTHER");} outm->SetDaughter(0, AliRsnDaughter::kKaon); outm->SetDaughter(1, AliRsnDaughter::kPion); outm->SetMotherPDG(Pdg);//313 outm->SetMotherMass(0.89594); // pair cuts outm->SetPairCuts(cutsPair); // binnings outm->AddAxis(imID, 90, 0.6, 1.5); outm->AddAxis(ptID, 300, 0.0, 30.0); if (!isPP){ outm->AddAxis(centID, 100, 0.0, 100.0); } else { outm->AddAxis(centID, 400, 0.0, 400.0); } //outm->AddAxis(yID, 32, -0.8, 0.8); } return kTRUE; }