void SetEventHistograms(AliRsnMiniAnalysisTask *task,ERsnCollisionType collisionType) { // -- 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(collisionType==kPP) 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 }
// // *** 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 ConfigPhiMC ( AliRsnMiniAnalysisTask *task, Bool_t isPP, const char *suffix, AliRsnCutSet *cutsPair ) { // manage suffix if (strlen(suffix) > 0) suffix = Form("_%s", suffix); // // -- Define track cuts ------------------------------------------------------------------------- // /*** EMPTY FOR TRUE PAIRS COMPUTATION ***/ // // -- 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 ----------------------------------------------------------------- // TString mode = "HIST"; if (!isPP) mode = "SPARSE"; // create output AliRsnMiniOutput *out = task->CreateOutput(Form("phi_TrueMC%s", suffix), mode.Data(), "MOTHER"); // selection settings out->SetDaughter(0, AliRsnDaughter::kKaon); out->SetDaughter(1, AliRsnDaughter::kKaon); out->SetMotherPDG(333); out->SetMotherMass(1.019455); // pair cuts out->SetPairCuts(cutsPair); // binnings out->AddAxis(imID, 500, 0.9, 1.4); out->AddAxis(ptID, 100, 0.0, 10.0); if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); return kTRUE; }
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; }
Bool_t ConfigPhiMassStudy ( AliRsnMiniAnalysisTask *task, Bool_t isMC, Bool_t isPP, const char *suffix, AliRsnCutSet *cutsPair, Int_t aodFilterBit = 5, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate = AliRsnCutSetDaughterParticle::kFastTPCpidNsigma, Float_t nsigmaKa = 2.0, Bool_t enableTrkSyst = kFALSE, Char_t DCAxyFormula[100] = "0.0105+0.035/pt^1.01", Double_t dcazmax = 3.2, Double_t minNcls = 70, Double_t maxX2cls = 4.0, Double_t globalX2cls = 36.0, Double_t minCrossedRows = 50.0, Double_t maxClsCrossedRows = 0.8, Bool_t enableMonitor = kTRUE, Bool_t IsMcTrueOnly = kFALSE, Int_t signedPdg = 333, TString monitorOpt = "", //Flag for AddMonitorOutput.C e.g."NoSIGN" Bool_t useCrossedRows = kFALSE, const char* yaxisVar = "PtDaughter_PDaughter_cent", //yaxisVar = "PtDaughter_PDaughter_cent" Bool_t useMixLS = 0 ) { TString opt(yaxisVar); opt.ToUpper(); Bool_t isPtDaughter = opt.Contains("PTDAUGHTER") ; Bool_t isPDaughter = opt.Contains("PDAUGHTER") ; Bool_t iscent = opt.Contains("CENT") ; Bool_t iseta = opt.Contains("ETA") ; Bool_t israpidity = opt.Contains("RAPIDITY") ; // manage suffix if (strlen(suffix) > 0) suffix = Form("_%s", suffix); // set daughter cuts AliRsnCutSetDaughterParticle * cutSetQ; AliRsnCutSetDaughterParticle * cutSetK; //vary track quality cuts for systematic checks if(enableTrkSyst){ AliRsnCutTrackQuality * trkQualityCut = new AliRsnCutTrackQuality("QualityCut"); trkQualityCut->SetAODTestFilterBit(aodFilterBit);//reset the filter bit cut trkQualityCut->SetCheckOnlyFilterBit(kFALSE);//tells the cut object to check all other cuts individually, trkQualityCut->SetDCARPtFormula(DCAxyFormula); trkQualityCut->SetDCAZmax(dcazmax); if(useCrossedRows) { trkQualityCut->SetMinNCrossedRowsTPC(minCrossedRows, kTRUE); trkQualityCut->SetMinNCrossedRowsOverFindableClsTPC(maxClsCrossedRows, kTRUE); } else trkQualityCut->SetTPCminNClusters(minNcls); trkQualityCut->SetTPCmaxChi2(maxX2cls); trkQualityCut->SetITSmaxChi2(36); // In Filter bit trkQualityCut->SetMaxChi2TPCConstrainedGlobal(globalX2cls); // In the Filterbit trkQualityCut->SetPtRange(0.15, 20.0); trkQualityCut->SetEtaRange(-0.8, 0.8); trkQualityCut->Print(); if(isPP) { cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), trkQualityCut, AliRsnCutSetDaughterParticle::kQualityStd2010, AliPID::kPion, -1.0); cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutKaCandidate, nsigmaKa), trkQualityCut, cutKaCandidate, AliPID::kKaon, nsigmaKa); } else { cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), trkQualityCut, AliRsnCutSetDaughterParticle::kQualityStd2011, AliPID::kPion, -1.0); cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutKaCandidate, nsigmaKa), trkQualityCut, cutKaCandidate, AliPID::kKaon, nsigmaKa); cutSetK->SetUse2011StdQualityCuts(kTRUE); } } else { //default cuts 2010 for pp and 2011 for p-Pb if(isPP) { cutSetQ = new AliRsnCutSetDaughterParticle("cutQuality", AliRsnCutSetDaughterParticle::kQualityStd2010, AliPID::kPion, -1.0, aodFilterBit, kFALSE); cutSetK = new AliRsnCutSetDaughterParticle(Form("cutKaon_%2.1f2sigma",nsigmaKa), cutKaCandidate, AliPID::kKaon, nsigmaKa, aodFilterBit, kFALSE); } else { cutSetQ = new AliRsnCutSetDaughterParticle("cutQuality", AliRsnCutSetDaughterParticle::kQualityStd2011, AliPID::kPion, -1.0, aodFilterBit, kFALSE); cutSetQ->SetUse2011StdQualityCuts(kTRUE); cutSetK = new AliRsnCutSetDaughterParticle(Form("cutKaon2011_%2.1f2sigma",nsigmaKa), cutKaCandidate, AliPID::kKaon, nsigmaKa, aodFilterBit, kFALSE); cutSetK->SetUse2011StdQualityCuts(kTRUE); } } Int_t iCutQ = task->AddTrackCuts(cutSetQ); Int_t iCutK = task->AddTrackCuts(cutSetK); if (enableMonitor){ Printf("======== Cut monitoring enabled"); gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C"); AddMonitorOutput(isMC, cutSetQ->GetMonitorOutput(), monitorOpt.Data()); AddMonitorOutput(isMC, cutSetK->GetMonitorOutput(), monitorOpt.Data()); } Int_t pdg = signedPdg; TDatabasePDG *db = TDatabasePDG::Instance(); TParticlePDG *part = db->GetParticle(pdg); Double_t mass = part->Mass(); // -- 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); /* 1st daughter pt */ Int_t fdpt = task->CreateValue(AliRsnMiniValue::kFirstDaughterPt, kFALSE); /* 2nd daughter pt */ Int_t sdpt = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kFALSE); /* 1st daughter p */ Int_t fdp = task->CreateValue(AliRsnMiniValue::kFirstDaughterP, kFALSE); /* 2nd daughter p */ Int_t sdp = task->CreateValue(AliRsnMiniValue::kSecondDaughterP, kFALSE); /* transv. momentum */ Int_t ptIDmc = task->CreateValue(AliRsnMiniValue::kPt, kTRUE); /* 1st daughter pt */ Int_t fdptmc = task->CreateValue(AliRsnMiniValue::kFirstDaughterPt, kTRUE); /* 2nd daughter pt */ Int_t sdptmc = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kTRUE); // -- 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 [12] = { !IsMcTrueOnly, !IsMcTrueOnly, !IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly, isMC , isMC , isMC , isMC , useMixLS , useMixLS}; Bool_t useIM [12] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 , 1 , 1 }; TString name [12] = {"UnlikePM" , "UnlikeMP" , "MixingPM" , "MixingMP" , "LikePP" , "LikeMM" ,"TruesPM","TruesMP","ResPM" ,"ResMP" ,"MixingPP","MixingMM"}; TString comp [12] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" , "TRUE" , "TRUE" , "MIX" ,"MIX" }; TString output [12] = {"SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE","SPARSE" ,"SPARSE","SPARSE","SPARSE" ,"SPARSE"}; Char_t charge1 [12] = {'+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' }; Char_t charge2 [12] = {'-' , '+' , '-' , '+' , '+' , '-' , '-' , '+' , '-' , '+' ,'+' , '-' }; Int_t cutID1 [12] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK }; Int_t cutID2 [12] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK }; //TString output [10] = {"HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" }; for (Int_t i = 0; i < 12; i++) { if (!use[i]) continue; AliRsnMiniOutput *out = task->CreateOutput(Form("Phi_%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::kKaon); out->SetCharge(0, charge1[i]); out->SetCharge(1, charge2[i]); out->SetMotherPDG(pdg); out->SetMotherMass(mass); out->SetPairCuts(cutsPair); // axis X: invmass (or resolution) if (useIM[i]) out->AddAxis(imID, 800, 0.8, 1.6); else out->AddAxis(resID, 200, -0.02, 0.02); // axis Y: transverse momentum of pair as default - else chosen value out->AddAxis(ptID, 100, 0.0, 10.0); //default use mother pt if(isPtDaughter) { out->AddAxis(fdpt, 100, 0.0, 10.0); out->AddAxis(sdpt, 100, 0.0, 10.0); } if(isPDaughter) { out->AddAxis(fdp, 100, 0.0, 10.0); out->AddAxis(sdp, 100, 0.0, 10.0); } // axis Z: centrality-multiplicity if(iscent) { if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); else out->AddAxis(centID, 400, 0.0, 400.0); } // axis W: pseudorapidity if(iseta) out->AddAxis(etaID, 20, -1.0, 1.0); // axis J: rapidity if(israpidity) out->AddAxis(yID, 12, -0.6, 0.6); } if (isMC){ // create output AliRsnMiniOutput *outm = task->CreateOutput(Form("Phi_Mother%s", suffix), "SPARSE", "MOTHER"); outm->SetDaughter(0, AliRsnDaughter::kKaon); outm->SetDaughter(1, AliRsnDaughter::kKaon); outm->SetMotherPDG(pdg); outm->SetMotherMass(mass); // pair cuts outm->SetPairCuts(cutsPair); // binnings outm->AddAxis(imID, 800, 0.8, 1.6); // axis Y: transverse momentum of pair as default - else chosen value outm->AddAxis(ptID, 100, 0.0, 10.0); //default use mother pt if(isPtDaughter) { outm->AddAxis(fdpt, 100, 0.0, 10.0); outm->AddAxis(sdpt, 100, 0.0, 10.0); } if(isPDaughter) { outm->AddAxis(fdp, 100, 0.0, 10.0); outm->AddAxis(sdp, 100, 0.0, 10.0); } if(iscent) { if (!isPP) outm->AddAxis(centID, 100, 0.0, 100.0); else outm->AddAxis(centID, 400, 0.0, 400.0); } // axis W: pseudorapidity if(iseta) outm->AddAxis(etaID, 20, -1.0, 1.0); // axis J: rapidity if(israpidity) outm->AddAxis(yID, 12, -0.6, 0.6); //create plot for generated Pt of mother vs generated Pt of daughters AliRsnMiniOutput *outPtGen = task->CreateOutput(Form("Phi_Mother_GenPt_%s", suffix), "SPARSE", "MOTHER"); outPtGen->SetDaughter(0, AliRsnDaughter::kKaon); outPtGen->SetDaughter(1, AliRsnDaughter::kKaon); outPtGen->SetMotherPDG(pdg); outPtGen->SetMotherMass(mass); // pair cuts outPtGen->SetPairCuts(cutsPair); // binnings outPtGen->AddAxis(ptIDmc, 100, 0.0, 10.0); //mother pt - generated outPtGen->AddAxis(fdptmc, 100, 0.0, 10.0); //first daughter pt - generated outPtGen->AddAxis(sdptmc, 100, 0.0, 10.0); //second daughter pt - generated //create plot for reconstructed Pt of true mother vs generated Pt of daughters AliRsnMiniOutput *outPtTrueGen = task->CreateOutput(Form("Phi_True_GenPt_%s", suffix), "SPARSE", "TRUE"); outPtTrueGen->SetDaughter(0, AliRsnDaughter::kKaon); outPtTrueGen->SetDaughter(1, AliRsnDaughter::kKaon); outPtTrueGen->SetCutID(0, iCutK); outPtTrueGen->SetCutID(1, iCutK); outPtTrueGen->SetCharge(0, '+'); outPtTrueGen->SetCharge(1, '-'); outPtTrueGen->SetMotherPDG(pdg); outPtTrueGen->SetMotherMass(mass); // pair cuts outPtTrueGen->SetPairCuts(cutsPair); // binnings outPtTrueGen->AddAxis(ptID, 100, 0.0, 10.0); //true pt - generated outPtTrueGen->AddAxis(fdptmc, 100, 0.0, 10.0); //first daughter pt - generated outPtTrueGen->AddAxis(sdptmc, 100, 0.0, 10.0); //second daughter pt - generated //create plot for reconstructed Pt of true mother vs reconstructed Pt of daughters AliRsnMiniOutput *outPtTrueRec = task->CreateOutput(Form("Phi_True_RecPt_%s", suffix), "SPARSE", "TRUE"); outPtTrueRec->SetDaughter(0, AliRsnDaughter::kKaon); outPtTrueRec->SetDaughter(1, AliRsnDaughter::kKaon); outPtTrueRec->SetCutID(0, iCutK); outPtTrueRec->SetCutID(1, iCutK); outPtTrueRec->SetCharge(0, '+'); outPtTrueRec->SetCharge(1, '-'); outPtTrueRec->SetMotherPDG(pdg); outPtTrueRec->SetMotherMass(mass); // pair cuts outPtTrueRec->SetPairCuts(cutsPair); // binnings outPtTrueRec->AddAxis(ptID, 100, 0.0, 10.0); //mother pt - reconstructed outPtTrueRec->AddAxis(fdpt, 100, 0.0, 10.0); //first daughter pt - reconstructed outPtTrueRec->AddAxis(sdpt, 100, 0.0, 10.0); //second daughter pt - reconstructed } return kTRUE; }
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; }
// // *** 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; }
// // *** 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; }
/*************************************************************************** [email protected] - last modified on 02/07/2014 *** Configuration script for K*, anti-K* analysis of 2010 pp 7TeV datasets *** This analysis task is used to extend the pT reach of the K* spectra published in Eur. Phys. J. C72(2012)2183. ****************************************************************************/ Bool_t ConfigKStarPP7TeV ( AliRsnMiniAnalysisTask *task, Bool_t isMC, Bool_t isPP, const char *suffix, AliRsnCutSet *cutsPair, Int_t aodFilterBit = 5, Int_t customQualityCutsID = AliRsnCutSetDaughterParticle::kDisableCustom, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutPiCandidate = AliRsnCutSetDaughterParticle::kQualityStd2010, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate = AliRsnCutSetDaughterParticle::kQualityStd2010, Float_t nsigmaPi = 2.0, Float_t nsigmaKa = 2.0, Bool_t enableMonitor = kTRUE, Bool_t IsMcTrueOnly = kFALSE, TString monitorOpt = "", Bool_t useMixLS = 0, Bool_t checkReflex = 0, AliRsnMiniValue::EType yaxisVar = AliRsnMiniValue::kPt ) { // manage suffix if (strlen(suffix) > 0) suffix = Form("_%s", suffix); // set daughter cuts AliRsnCutSetDaughterParticle * cutSetQ; AliRsnCutSetDaughterParticle * cutSetPi; AliRsnCutSetDaughterParticle * cutSetK; AliRsnCutTrackQuality * trkQualityCut = new AliRsnCutTrackQuality("myQualityCut"); if (SetCustomQualityCut(trkQualityCut, customQualityCutsID, aodFilterBit)) { //Set custom quality cuts for systematic checks cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), trkQualityCut, AliRsnCutSetDaughterParticle::kQualityStd2010, AliPID::kPion, -1.0); cutSetPi = new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",cutPiCandidate, nsigmaPi), trkQualityCut, cutPiCandidate, AliPID::kPion, nsigmaPi); cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutPiCandidate, nsigmaKa), trkQualityCut, cutKaCandidate, AliPID::kKaon, nsigmaKa); } else { //use default quality cuts std 2010 with crossed rows TPC Bool_t useCrossedRows = 1; cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), AliRsnCutSetDaughterParticle::kQualityStd2010, AliPID::kPion, -1.0, aodFilterBit, useCrossedRows); cutSetPi = new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",cutPiCandidate, nsigmaPi), cutPiCandidate, AliPID::kPion, nsigmaPi, aodFilterBit, useCrossedRows); cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutPiCandidate, nsigmaKa), cutKaCandidate, AliPID::kKaon, nsigmaKa, aodFilterBit, useCrossedRows); } Int_t iCutQ = task->AddTrackCuts(cutSetQ); Int_t iCutPi = task->AddTrackCuts(cutSetPi); Int_t iCutK = task->AddTrackCuts(cutSetK); if (enableMonitor){ Printf("======== Cut monitoring enabled"); gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C"); AddMonitorOutput(isMC, cutSetQ->GetMonitorOutput(), monitorOpt.Data()); AddMonitorOutput(isMC, cutSetPi->GetMonitorOutput(), monitorOpt.Data()); AddMonitorOutput(isMC, cutSetK->GetMonitorOutput()), monitorOpt.Data(); } // -- 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); /* 1st daughter pt */ Int_t fdpt = task->CreateValue(AliRsnMiniValue::kFirstDaughterPt, kFALSE); /* 2nd daughter pt */ Int_t sdpt = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kFALSE); /* 1st daughter p */ Int_t fdp = task->CreateValue(AliRsnMiniValue::kFirstDaughterP, kFALSE); /* 2nd daughter p */ Int_t sdp = task->CreateValue(AliRsnMiniValue::kSecondDaughterP, 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 [12] = {!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly ,isMC,isMC,isMC,isMC, useMixLS , useMixLS }; Bool_t useIM [12] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 , 1 , 1 }; TString name [12] = {"UnlikePM", "UnlikeMP","MixingPM","MixingMP", "LikePP", "LikeMM","TruesPM","TruesMP", "ResPM" ,"ResMP" , "MixingPP", "MixingMM" }; TString comp [12] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" , "TRUE" ,"TRUE" , "MIX" , "MIX" }; TString output [12] = {"SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE", "SPARSE", "SPARSE","SPARSE" , "SPARSE","SPARSE", "SPARSE" , "SPARSE" }; Int_t pdgCode [12] = {313 , 313 , 313 , 313 , 313 , 313 , 313 , -313 , 313 , -313 , 313 , 313 }; Char_t charge1 [12] = {'+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' }; Char_t charge2 [12] = {'-' , '+' , '-' , '+' , '+' , '-' , '-' , '+' , '-' , '+' , '+' , '-' }; Int_t cutID1 [12] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK }; Int_t cutID2 [12] = { iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi, iCutPi , iCutPi , iCutPi , iCutPi }; for (Int_t i = 0; i < 12; i++) { if (!use[i]) continue; AliRsnMiniOutput *out = task->CreateOutput(Form("kstar_%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(pdgCode[i]); 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 of pair as default - else chosen value if (yaxisVar==AliRsnMiniValue::kFirstDaughterPt) out->AddAxis(fdpt, 100, 0.0, 10.0); else if (yaxisVar==AliRsnMiniValue::kSecondDaughterPt) out->AddAxis(sdpt, 100, 0.0, 10.0); else if (yaxisVar==AliRsnMiniValue::kFirstDaughterP) out->AddAxis(fdp, 100, 0.0, 10.0); else if (yaxisVar==AliRsnMiniValue::kSecondDaughterP) out->AddAxis(sdp, 100, 0.0, 10.0); else out->AddAxis(ptID, 200, 0.0, 20.0); //default use mother pt // 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, 10, -0.5, 0.5); } if (isMC){ //get mothers for K* PDG = 313 AliRsnMiniOutput *outm = task->CreateOutput(Form("Ks_Mother%s", suffix), "SPARSE", "MOTHER"); outm->SetDaughter(0, AliRsnDaughter::kKaon); outm->SetDaughter(1, AliRsnDaughter::kPion); outm->SetMotherPDG(313); outm->SetMotherMass(0.89594); outm->SetPairCuts(cutsPair); outm->AddAxis(imID, 90, 0.6, 1.5); outm->AddAxis(ptID, 200, 0.0, 20.0); if (!isPP){ outm->AddAxis(centID, 100, 0.0, 100.0); } else { outm->AddAxis(centID, 400, 0.0, 400.0); } //get mothers for antiK* PDG = -313 AliRsnMiniOutput *outam = task->CreateOutput(Form("antiKs_Mother%s", suffix), "SPARSE", "MOTHER"); outam->SetDaughter(0, AliRsnDaughter::kKaon); outam->SetDaughter(1, AliRsnDaughter::kPion); outam->SetMotherPDG(-313); outam->SetMotherMass(0.89594); outam->SetPairCuts(cutsPair); outam->AddAxis(imID, 90, 0.6, 1.5); outam->AddAxis(ptID, 200, 0.0, 20.0); if (!isPP){ outam->AddAxis(centID, 100, 0.0, 100.0); } else { outam->AddAxis(centID, 400, 0.0, 400.0); } //get phase space of the decay from mothers AliRsnMiniOutput *outps = task->CreateOutput(Form("Ks_phaseSpace%s", suffix), "HIST", "TRUE"); outps->SetDaughter(0, AliRsnDaughter::kKaon); outps->SetDaughter(1, AliRsnDaughter::kPion); outps->SetCutID(0, iCutK); outps->SetCutID(1, iCutPi); outps->SetMotherPDG(313); outps->SetMotherMass(0.89594); outps->SetPairCuts(cutsPair); outps->AddAxis(fdpt, 50, 0.0, 5.0); outps->AddAxis(sdpt, 50, 0.0, 5.0); outps->AddAxis(ptID, 200, 0.0, 20.0); AliRsnMiniOutput *outaps = task->CreateOutput(Form("antiKs_phaseSpace%s", suffix), "HIST", "TRUE"); outaps->SetDaughter(0, AliRsnDaughter::kKaon); outaps->SetDaughter(1, AliRsnDaughter::kPion); outaps->SetCutID(0, iCutK); outaps->SetCutID(1, iCutPi); outaps->SetMotherPDG(-313); outaps->SetMotherMass(0.89594); outaps->SetPairCuts(cutsPair); outaps->AddAxis(fdpt, 50, 0.0, 5.0); outaps->AddAxis(sdpt, 50, 0.0, 5.0); outaps->AddAxis(ptID, 200, 0.0, 20.0); //get reflections if (checkReflex) { AliRsnMiniOutput *outreflex = task->CreateOutput(Form("Ks_reflex%s", suffix), "SPARSE", "TRUE"); outreflex->SetDaughter(0, AliRsnDaughter::kKaon); outreflex->SetDaughter(1, AliRsnDaughter::kPion); outreflex->SetCutID(0, iCutPi); outreflex->SetCutID(1, iCutK); outreflex->SetMotherPDG(313); outreflex->SetMotherMass(0.89594); outreflex->SetPairCuts(cutsPair); outreflex->AddAxis(imID, 90, 0.6, 1.5); outreflex->AddAxis(ptID, 200, 0.0, 20.0); if (!isPP){ outreflex->AddAxis(centID, 100, 0.0, 100.0); } else { outreflex->AddAxis(centID, 400, 0.0, 400.0); } AliRsnMiniOutput *outareflex = task->CreateOutput(Form("antiKs_reflex%s", suffix), "SPARSE", "TRUE"); outareflex->SetDaughter(0, AliRsnDaughter::kKaon); outareflex->SetDaughter(1, AliRsnDaughter::kPion); outareflex->SetCutID(0, iCutPi); outareflex->SetCutID(1, iCutK); outareflex->SetMotherPDG(-313); outareflex->SetMotherMass(0.89594); outareflex->SetPairCuts(cutsPair); outareflex->AddAxis(imID, 90, 0.6, 1.5); outareflex->AddAxis(ptID, 200, 0.0, 20.0); if (!isPP){ outareflex->AddAxis(centID, 100, 0.0, 100.0); } else { outareflex->AddAxis(centID, 400, 0.0, 400.0); } }//end reflections }//end MC return kTRUE; }
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; }
// // *** 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; }
Bool_t ConfigKstarPP13TeV( AliRsnMiniAnalysisTask *task, Bool_t isMC, Bool_t isPP, const char *suffix, AliRsnCutSet *cutsPair, Float_t nsigmaPi = 3.0, Float_t nsigmaK = 3.0, Bool_t enableMonitor = kTRUE, TString optSys = "DefaultITSTPC2011" ) { //These are the Default values for 2011 ESD track cuts AliPID::EParticleType type1 = AliPID::kPion; AliPID::EParticleType type2 = AliPID::kKaon; // manage suffix if (strlen(suffix) > 0) suffix = Form("_%s", suffix); // retrieve mass from PDG database Int_t pdg = 313; TDatabasePDG *db = TDatabasePDG::Instance(); TParticlePDG *part = db->GetParticle(pdg); Double_t mass = part->Mass(); // set daughter cuts AliRsnCutSetDaughterParticle* cutSetPi; AliRsnCutSetDaughterParticle* cutSetK; /* AliRsnCutTrackQuality* trkQualityCut= new AliRsnCutTrackQuality("myQualityCut"); if(optSyt.Contains("DefaultITSTPC2011")){ trkQualityCut->SetDefaults2011(kTRUE,kTRUE); Printf(Form("::::: SetCustomQualityCut:: using standard 2011 track quality cuts")); } else if(optSyt.Contains("DefaultTPCOnly")){ trkQualityCut->SetDefaultsTPCOnly(kTRUE); Printf(Form("::::: SetCustomQualityCut:: using TPC-only track quality cuts")); } trkQualityCut->Print();*/ 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); //kTPCpidTOFveto4s //kTPCpidTOFveto3s //kFastTPCpidNsigma cutSetPi=new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s,nsigmaPi),fQualityTrackCut,AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s,AliPID::kPion,nsigmaPi); cutSetK=new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s, nsigmaK),fQualityTrackCut,AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s,AliPID::kKaon,nsigmaK); Int_t iCutPi = task->AddTrackCuts(cutSetPi); Int_t iCutK = task->AddTrackCuts(cutSetK); if(enableMonitor){ Printf("======== Monitoring cut AliRsnCutSetDaughterParticle enabled"); gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C"); AddMonitorOutput(isMC, cutSetPi->GetMonitorOutput()); AddMonitorOutput(isMC, cutSetK->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 [12] = {1 ,1 ,1 ,1 ,1 ,1 ,isMC ,isMC ,isMC ,isMC ,isMC ,isMC }; Bool_t useIM [12] = {1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,0 ,0 }; TString name [12] = {"UnlikePM","UnlikeMP","MixingPM","MixingMP","LikePP","LikeMM","MCGenPM","MCGenMP","TruesPM","TruesMP","ResPM" ,"ResMP" }; TString comp [12] = {"PAIR" ,"PAIR" ,"MIX" ,"MIX" ,"PAIR" ,"PAIR" ,"MOTHER" ,"MOTHER" ,"TRUE" ,"TRUE" ,"TRUE" ,"TRUE" }; TString output [12] = {"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE","SPARSE","SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE","SPARSE"}; Char_t charge1 [12] = {'+' ,'-' ,'+' ,'-' ,'+' ,'-' ,'+' ,'-' ,'+' ,'-' ,'+' ,'-' }; Char_t charge2 [12] = {'-' ,'+' ,'-' ,'+' ,'+' ,'-' ,'-' ,'+' ,'_' ,'+' ,'-' ,'+' }; Int_t cutIDPi [12] = {iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi }; Int_t cutIDK [12] = {iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK }; Int_t PDGCode [12] = {313 ,313 ,313 ,313 ,313 ,313 ,313 ,-313 ,313 ,313 ,313 ,-313 }; for (Int_t i = 0; i < 12; i++) { if (!use[i]) continue; AliRsnMiniOutput *out = task->CreateOutput(Form("KSTAR_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data()); out->SetDaughter(0, AliRsnDaughter::kKaon); out->SetDaughter(1, AliRsnDaughter::kPion); out->SetCutID(0, cutIDK[i]); out->SetCutID(1, cutIDPi[i]); out->SetCharge(0, charge1[i]); out->SetCharge(1, charge2[i]); out->SetMotherPDG(PDGCode[i]); out->SetMotherMass(mass); 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, 200, 0.0, 20.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, 90, -4.5, 4.5); } 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 ConfigDeltaPP7TeV_MC ( AliRsnMiniAnalysisTask *task, Bool_t isPP, const char *suffix, AliRsnCutSet *cutsPair ) { // manage suffix if (strlen(suffix) > 0) suffix = Form("_%s", suffix); // // -- Define track cuts ------------------------------------------------------------------------- // /*** EMPTY FOR TRUE PAIRS COMPUTATION ***/ // // -- 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); /* pseudorapidity */ Int_t etaID = task->CreateValue(AliRsnMiniValue::kEta , kFALSE); /* rapidity */ Int_t yID = task->CreateValue(AliRsnMiniValue::kY , kFALSE); // // -- Create all needed outputs ----------------------------------------------------------------- // TString mode = "SPARSE"; //if (!isPP) mode = "SPARSE"; //DELTA++ // create output AliRsnMiniOutput *outpp = task->CreateOutput(Form("deltapp_TrueMCGen%s", suffix), mode.Data(), "MOTHER"); outpp->SetDaughter(0, AliRsnDaughter::kProton); outpp->SetDaughter(1, AliRsnDaughter::kPion); outpp->SetMotherPDG(2224); outpp->SetMotherMass(1.232); outpp->SetPairCuts(cutsPair); outpp->AddAxis( imID , 100 , 1.0, 2.0 ); outpp->AddAxis( ptID , 100 , 0.0, 10.0 ); outpp->AddAxis(centID , 120 , 0.0, 120 ); outpp->AddAxis( etaID , 20 ,-1.0, 1.0 ); outpp->AddAxis( yID , 10 ,-0.5, 0.5 ); //DELTA-- AliRsnMiniOutput *outmm = task->CreateOutput(Form("deltamm_TrueMCGen%s", suffix), mode.Data(), "MOTHER"); outmm->SetDaughter(0, AliRsnDaughter::kProton); outmm->SetDaughter(1, AliRsnDaughter::kPion); outmm->SetMotherPDG(-2224); outmm->SetMotherMass(1.232); outmm->SetPairCuts(cutsPair); outmm->AddAxis( imID , 100 , 1.0, 2.0 ); outmm->AddAxis( ptID , 100 , 0.0, 10.0 ); outmm->AddAxis( centID , 120 , 0.0, 120 ); outmm->AddAxis( etaID , 20 ,-1.0, 1.0 ); outmm->AddAxis( yID , 10 ,-0.5, 0.5 ); //DELTA0 AliRsnMiniOutput *out0pm = task->CreateOutput(Form("delta0pm_TrueMCGen%s", suffix), mode.Data(), "MOTHER"); out0pm->SetDaughter(0, AliRsnDaughter::kProton); out0pm->SetDaughter(1, AliRsnDaughter::kPion); out0pm->SetMotherPDG(2114); out0pm->SetMotherMass(1.232); out0pm->SetPairCuts(cutsPair); out0pm->AddAxis( imID , 100 , 1.0, 2.0 ); out0pm->AddAxis( ptID , 100 , 0.0, 10.0 ); out0pm->AddAxis( centID , 120 , 0.0, 120 ); out0pm->AddAxis( etaID , 20 ,-1.0, 1.0 ); out0pm->AddAxis( yID , 10 ,-0.5, 0.5 ); //DELTA0BAR AliRsnMiniOutput *out0mp = task->CreateOutput(Form("delta0mp_TrueMCGen%s", suffix), mode.Data(), "MOTHER"); out0mp->SetDaughter(0, AliRsnDaughter::kProton); out0mp->SetDaughter(1, AliRsnDaughter::kPion); out0mp->SetMotherPDG(-2114); out0mp->SetMotherMass(1.232); out0mp->SetPairCuts(cutsPair); out0mp->AddAxis( imID , 100 , 1.0, 2.0 ); out0mp->AddAxis( ptID , 100 , 0.0, 10.0 ); out0mp->AddAxis( centID , 120 , 0.0, 120 ); out0mp->AddAxis( etaID , 20 ,-1.0, 1.0 ); out0mp->AddAxis( yID , 10 ,-0.5, 0.5 ); return kTRUE; }
Bool_t ConfigPhiPP5TeV( AliRsnMiniAnalysisTask *task, Bool_t isMC, Bool_t isPP, const char *suffix, AliRsnCutSet *cutsPair, Int_t Strcut = 2011, Int_t customQualityCutsID = AliRsnCutSetDaughterParticle::kDisableCustom, AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate=AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s, Float_t nsigmaK = 3.0, Bool_t enableMonitor = kTRUE ) { //These are the Default values for 2011 ESD track cuts AliPID::EParticleType type2 = AliPID::kKaon; // manage suffix if (strlen(suffix) > 0) suffix = Form("_%s", suffix); // retrieve mass from PDG database Int_t pdg = 333; TDatabasePDG *db = TDatabasePDG::Instance(); TParticlePDG *part = db->GetParticle(pdg); Double_t mass = part->Mass(); Float_t nsigmaKTPC=fmod(nsigmaK,1000.); Float_t nsigmaKTOF=(nsigmaK-fmod(nsigmaK,1000.))/1000.; if(nsigmaKTOF<1.e-10) nsigmaKTOF=-1.; // set daughter cuts AliRsnCutSetDaughterParticle* cutSetK; AliRsnCutTrackQuality* trkQualityCut= new AliRsnCutTrackQuality("myQualityCut"); if(!trkQualityCut) return kFALSE; if(SetCustomQualityCut(trkQualityCut,customQualityCutsID,Strcut)){ cutSetK=new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutKaCandidate, nsigmaK),trkQualityCut,cutKaCandidate,AliPID::kKaon,nsigmaKTPC,nsigmaKTOF); } else{ printf("Doughter Track cuts has been selected =================\n"); return kFALSE; } Int_t iCutK = task->AddTrackCuts(cutSetK); if(enableMonitor){ Printf("======== Monitoring cut AliRsnCutSetDaughterParticle enabled"); gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C"); AddMonitorOutput(isMC, cutSetK->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 [7] = {1 ,1 ,1 ,1 ,isMC ,isMC ,isMC }; Bool_t useIM [7] = {1 ,1 ,1 ,1 ,1 ,1 ,0 }; TString name [7] = {"Unlike" ,"Mixing" ,"LikePP" ,"LikeMM" ,"MCGen" ,"Trues", ,"ResMP" }; TString comp [7] = {"PAIR" ,"MIX" ,"PAIR" ,"PAIR" ,"MOTHER" ,"TRUE" ,"TRUE" }; TString output [7] = {"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE"}; Char_t charge1 [7] = {'+' ,'+' ,'+' ,'-' ,'+' ,'+' ,'+' }; Char_t charge2 [7] = {'-' ,'-' ,'+' ,'-' ,'-' ,'-' ,'-' }; Int_t cutIDK [7] = {iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK }; Int_t PDGCode [7] = {333 ,333 ,333 ,333 ,333 ,333 ,333 }; for (Int_t i = 0; i < 7; i++) { if (!use[i]) continue; AliRsnMiniOutput *out = task->CreateOutput(Form("PHI_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data()); out->SetDaughter(0, AliRsnDaughter::kKaon); out->SetDaughter(1, AliRsnDaughter::kKaon); out->SetCutID(0, cutIDK[i]); out->SetCutID(1, cutIDK[i]); out->SetCharge(0, charge1[i]); out->SetCharge(1, charge2[i]); out->SetMotherPDG(PDGCode[i]); out->SetMotherMass(mass); out->SetPairCuts(cutsPair); // axis X: invmass (or resolution) if (useIM[i]) out->AddAxis(imID, 250, 0.95, 1.2); else out->AddAxis(resID, 200, -0.02, 0.02); // axis Y: transverse momentum out->AddAxis(ptID, 500, 0.0, 50.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, 90, -4.5, 4.5); } return kTRUE; } Bool_t SetCustomQualityCut(AliRsnCutTrackQuality * trkQualityCut, Int_t customQualityCutsID = 0,Int_t trCut = 2011) { //Sets configuration for track quality object different from std quality cuts. //Returns kTRUE if track quality cut object is successfully defined, //returns kFALSE if an invalid set of cuts (customQualityCutsID) is chosen or if the //object to be configured does not exist. if ((!trkQualityCut)){ Printf("::::: SetCustomQualityCut:: use default quality cuts specified in task configuration."); return kFALSE; } if(customQualityCutsID>=1 && customQualityCutsID<100 && customQualityCutsID!=2){ if(trCut == 2011){ trkQualityCut->SetDefaults2011(kTRUE,kTRUE); Printf(Form("::::: SetCustomQualityCut:: using standard 2011 track quality cuts")); } else if(trCut == 2015){ trkQualityCut->SetDefaults2011(kTRUE,kTRUE); trkQualityCut->GetESDtrackCuts()->SetCutGeoNcrNcl(3., 130., 1.5, 0.85, 0.7); Printf(Form("::::: SetCustomQualityCut:: using standard 2015 track quality cuts")); } if(customQualityCutsID==3){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexXYPtDep("0.015+0.05/pt^1.1");}//10Sig // D = 7*(0.0015+0.0050/pt^1.1) else if(customQualityCutsID==4){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexXYPtDep("0.006+0.02/pt^1.1");}//4Sig else if(customQualityCutsID==5){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexZ(3.);}// D = 2. else if(customQualityCutsID==6){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexZ(1.);} else if(customQualityCutsID==7){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexZ(0.2);} else if(customQualityCutsID==8){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterTPC(5.);}// D = 4 else if(customQualityCutsID==9){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterTPC(3);} else if(customQualityCutsID==10){trkQualityCut->GetESDtrackCuts()->SetMinNCrossedRowsTPC(60);}// D = 70 else if(customQualityCutsID==11){trkQualityCut->GetESDtrackCuts()->SetMinNCrossedRowsTPC(80);} else if(customQualityCutsID==12){trkQualityCut->GetESDtrackCuts()->SetMinNCrossedRowsTPC(100);} else if(customQualityCutsID==13){trkQualityCut->GetESDtrackCuts()->SetMinRatioCrossedRowsOverFindableClustersTPC(0.7);}// D = 8 else if(customQualityCutsID==14){trkQualityCut->GetESDtrackCuts()->SetMinRatioCrossedRowsOverFindableClustersTPC(0.9);} else if(customQualityCutsID==15){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterITS(49.);}// D = 36 else if(customQualityCutsID==16){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterITS(25.);} else if(customQualityCutsID==17){trkQualityCut->GetESDtrackCuts()->SetMaxChi2TPCConstrainedGlobal(49.);}// D = 36 else if(customQualityCutsID==18){trkQualityCut->GetESDtrackCuts()->SetMaxChi2TPCConstrainedGlobal(25.);} else if(customQualityCutsID==19){trkQualityCut->GetESDtrackCuts()->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kOff);} trkQualityCut->Print(); return kTRUE; }else if(customQualityCutsID==2 || (customQualityCutsID>=100 && customQualityCutsID<200)){ trkQualityCut->SetDefaultsTPCOnly(kTRUE); Printf(Form("::::: SetCustomQualityCut:: using TPC-only track quality cuts")); if(customQualityCutsID==103){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexXY(3.);} else if(customQualityCutsID==104){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexXY(1.);} else if(customQualityCutsID==105){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexZ(4.);} else if(customQualityCutsID==106){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexZ(1.);} else if(customQualityCutsID==107){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterTPC(7.);} else if(customQualityCutsID==108){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterTPC(2.5);} else if(customQualityCutsID==109){trkQualityCut->GetESDtrackCuts()->SetMinNClustersTPC(30);} else if(customQualityCutsID==110){trkQualityCut->GetESDtrackCuts()->SetMinNClustersTPC(85);} trkQualityCut->Print(); return kTRUE; }else{ Printf("::::: SetCustomQualityCut:: use default quality cuts specified in task configuration."); return kFALSE; } trkQualityCut->SetPtRange(0.15, 100000.0); trkQualityCut->SetEtaRange(-0.8, 0.8); Printf(Form("::::: SetCustomQualityCut:: using custom track quality cuts #%i",customQualityCutsID)); trkQualityCut->Print(); 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 ConfigLStarPP_MC ( AliRsnMiniAnalysisTask *task, Bool_t isPP, const char *suffix, AliRsnCutSet *cutsPair ) { // manage suffix if (strlen(suffix) > 0) suffix = Form("_%s", suffix); // // -- Define track cuts ------------------------------------------------------------------------- // /*** EMPTY FOR TRUE PAIRS COMPUTATION ***/ // // -- 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 ----------------------------------------------------------------- // TString mode = "SPARSE"; // if (!isPP) mode = "SPARSE"; // create output AliRsnMiniOutput *out = task->CreateOutput(Form("LStar_TrueMC1%s", suffix), mode.Data(), "MOTHER"); // selection settings out->SetDaughter(0, AliRsnDaughter::kProton); out->SetDaughter(1, AliRsnDaughter::kKaon); out->SetCharge(0, '+'); out->SetCharge(1, '-'); out->SetMotherPDG(3124); out->SetMotherMass(1.520); // pair cuts out->SetPairCuts(cutsPair); // binnings out->AddAxis(imID, 80, 1.0, 2.0); //S.K. out->AddAxis(ptID, 100, 0.0, 10.0); out->AddAxis(ptID, 100, 0.0, 10.0); //S.K. if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); out->AddAxis(centID, 10, 0.0, 100.0); // create output AliRsnMiniOutput *out = task->CreateOutput(Form("LStar_TrueMC2%s", suffix), mode.Data(), "MOTHER"); // selection settings out->SetDaughter(0, AliRsnDaughter::kProton); out->SetDaughter(1, AliRsnDaughter::kKaon); out->SetCharge(0, '-'); out->SetCharge(1, '+'); out->SetMotherPDG(-3124); out->SetMotherMass(1.520); // pair cuts out->SetPairCuts(cutsPair); // binnings out->AddAxis(imID, 100, 1.0, 2.0); //S.K. out->AddAxis(ptID, 100, 0.0, 10.0); out->AddAxis(ptID, 100, 0.0, 10.0); //S.K. if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0); out->AddAxis(centID, 10, 0.0, 100.0); // create output AliRsnMiniOutput *outm = task->CreateOutput(Form("Ls_Mother"), mode.Data(), "MOTHER"); outm->SetDaughter(0, AliRsnDaughter::kProton); outm->SetDaughter(1, AliRsnDaughter::kKaon); outm->SetMotherPDG(3124); outm->SetMotherMass(1.520); // pair cuts outm->SetPairCuts(cutsPair); // binnings outm->AddAxis(imID, 100, 1.0, 2.0); outm->AddAxis(ptID, 100, 0.0, 10.0); if (!isPP){ outm->AddAxis(centID, 100, 0.0, 100.0); } else { outm->AddAxis(centID, 400, 0.0, 400.0); } AliRsnMiniOutput *outm = task->CreateOutput(Form("Ls_AntiMother"), mode.Data(), "MOTHER"); outm->SetDaughter(0, AliRsnDaughter::kProton); outm->SetDaughter(1, AliRsnDaughter::kKaon); outm->SetMotherPDG(-3124); outm->SetMotherMass(1.520); // pair cuts outm->SetPairCuts(cutsPair); // binnings outm->AddAxis(imID, 100, 1.0, 2.0); outm->AddAxis(ptID, 100, 0.0, 10.0); if (!isPP){ outm->AddAxis(centID, 100, 0.0, 100.0); } else { outm->AddAxis(centID, 400, 0.0, 400.0); } return kTRUE; }
void AddPairOutputMiniRho(AliAnalysisTaskSE *task, Bool_t isMC,Bool_t isMixing, AliPID::EParticleType pType1,Int_t listID1, AliPID::EParticleType pType2,Int_t listID2, Int_t pdgMother,Double_t massMother, AliRsnCutSet *cutsPair=0,TString suffix = "") { Bool_t valid; Int_t isFullOutput = AliAnalysisManager::GetGlobalInt("rsnOutputFull",valid); Int_t useMixing = AliAnalysisManager::GetGlobalInt("rsnUseMixing",valid); Int_t isPP = AliAnalysisManager::GetGlobalInt("rsnIsPP",valid); AliRsnMiniAnalysisTask *taskRsnMini = (AliRsnMiniAnalysisTask *)task; /* invariant mass */ Int_t imID = taskRsnMini->CreateValue(AliRsnMiniValue::kInvMass, kFALSE); /* IM resolution */ Int_t resID = taskRsnMini->CreateValue(AliRsnMiniValue::kInvMassDiff, kTRUE); /* transv. momentum */ Int_t ptID = taskRsnMini->CreateValue(AliRsnMiniValue::kPt, kFALSE); /* centrality */ Int_t centID = taskRsnMini->CreateValue(AliRsnMiniValue::kMult, kFALSE); /* eta */ Int_t etaID = taskRsnMini->CreateValue(AliRsnMiniValue::kEta, kFALSE); // 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 [5] = { 1 , useMixing , 1 , 1 , isMC }; TString name [5] = {"Unlike", "Mixing", "LikePP", "LikeMM", "Trues"}; TString comp [5] = {"PAIR" , "MIX" , "PAIR" , "PAIR" , "TRUE" }; Char_t charge1 [5] = {'+' , '+' , '+' , '-' , '+' }; Char_t charge2 [5] = {'-' , '-' , '+' , '-' , '-' }; // common definitions TString outputType = "HIST"; if (isFullOutput) outputType = "SPARSE"; Int_t nIM = 1000; Double_t minIM = 0.2, maxIM = 1.2; Int_t nEta = 400; Double_t minEta = -2.0, maxEta = 2.0; // Int_t nIM = 1000; Double_t minIM = 0.9, maxIM = 1.9; Int_t nPt = 120; Double_t minPt = 0.0, maxPt = 12.0; Int_t nCent = 100; Double_t minCent = 0.0, maxCent = 100.0; Int_t nRes = 200; Double_t maxRes = 0.01; // retrieve mass from PDG database Int_t pdg = 113; TDatabasePDG *db = TDatabasePDG::Instance(); TParticlePDG *part = db->GetParticle(pdg); Printf(suffix.Data()); // create standard outputs for (Int_t i = 0; i < 5; i++) { if (!use[i]) continue; // create output AliRsnMiniOutput *out = taskRsnMini->CreateOutput(Form("%s_%s", suffix.Data(),name[i].Data() ), outputType.Data(), comp[i].Data()); // selection settings out->SetCutID(0, listID1); out->SetCutID(1, listID1); out->SetDaughter(0, AliRsnDaughter::kPion); out->SetDaughter(1, AliRsnDaughter::kPion); out->SetCharge(0, charge1[i]); out->SetCharge(1, charge2[i]); out->SetMotherPDG(pdg); out->SetMotherMass(part->Mass()); // pair cuts if (cutsPair) out->SetPairCuts(cutsPair); // axis X: invmass out->AddAxis(imID, nIM, minIM, maxIM); if (isFullOutput) { // axis Y: transverse momentum out->AddAxis(ptID, nPt, minPt, maxPt); out->AddAxis(etaID, nEta, minEta, maxEta); // axis Z: centrality if (!isPP) out->AddAxis(centID, nCent, minCent, maxCent); } } // add output for resolution if (isMC) { AliRsnMiniOutput *outRes = taskRsnMini->CreateOutput(Form("rho_Res%s", suffix.Data()), outputType.Data(), "TRUE"); // selection settings outRes->SetCutID(0, listID1); outRes->SetCutID(1, listID1); outRes->SetDaughter(0, AliRsnDaughter::kPion); outRes->SetDaughter(1, AliRsnDaughter::kPion); outRes->SetCharge(0, '+'); outRes->SetCharge(1, '-'); outRes->SetMotherPDG(pdg); outRes->SetMotherMass(part->Mass()); // pair cuts if (cutsPair) outRes->SetPairCuts(cutsPair); // axis X: resolution outRes->AddAxis(resID, nRes, -maxRes, maxRes); if (isFullOutput) { // axis Y: transverse momentum outRes->AddAxis(ptID, nPt, minPt, maxPt); outRes->AddAxis(etaID, nEta, minEta, maxEta); // axis Z: centrality if (!isPP) outRes->AddAxis(centID, nCent, minCent, maxCent); } } // // -- Create output for MC generated ------------------------------------------------------------ // if (isMC) { // create ouput AliRsnMiniOutput *outMC = taskRsnMini->CreateOutput(Form("rho_MCGen%s", suffix.Data()), outputType.Data(), "MOTHER"); // selection settings outMC->SetDaughter(0, AliRsnDaughter::kPion); outMC->SetDaughter(1, AliRsnDaughter::kPion); outMC->SetMotherPDG(pdg); outMC->SetMotherMass(part->Mass()); // pair cuts if (cutsPair) outMC->SetPairCuts(cutsPair); // axis X: invmass outMC->AddAxis(imID, nIM, minIM, maxIM); if (isFullOutput) { // axis Y: transverse momentum outMC->AddAxis(ptID, nPt, minPt, maxPt); outMC->AddAxis(etaID, nEta, minEta, maxEta); // axis Z: centrality if (!isPP) outMC->AddAxis(centID, nCent, minCent, maxCent); } } }
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; }