--- /dev/null
+/***************************************************************************
+ fbellini@cern.ch - last modified on 06/08/2012
+//
+// General macro to configure the RSN analysis task.
+// It calls all configs desired by the user, by means
+// of the boolean switches defined in the first lines.
+// ---
+// Inputs:
+// 1) flag to know if running on MC or data
+// 2) path where all configs are stored
+// ---
+// Returns:
+// kTRUE --> initialization successful
+// kFALSE --> initialization failed (some config gave errors)
+//
+****************************************************************************/
+
+AliRsnMiniAnalysisTask * AddAnalysisTaskD0
+(
+ Bool_t isMC,
+ Bool_t isPP,
+ Float_t cutV = 10.0,
+ Int_t aodFilterBit = 5,
+ Float_t nsigmaTPCPi = 3.0,
+ Float_t nsigmaTPCKa = 3.0,
+ Float_t nsigmaTOFPi = 2.0,
+ Float_t nsigmaTOFKa = 2.0,
+ Float_t trackDCAcutMax = 7.0,
+ Float_t trackDCAcutMin = 0.0,
+ Int_t NTPCcluster = 70,
+ Double_t minpt = 0.15,
+ TString triggerMask = AliVEvent::kMB,
+ Int_t nmix = 5,
+ Double_t minYlab = -0.5,
+ Double_t maxYlab = 0.5,
+ Double_t dcaProduct = 1E-4,
+ Float_t maxDiffVzMix = 1.0,
+ Float_t maxDiffMultMix = 10.0,
+ Float_t maxDiffAngleMixDeg = 20.0,
+ Int_t aodN = 0,
+ TString outNameSuffix = "D0"
+)
+{
+ //
+ // -- INITIALIZATION ----------------------------------------------------------------------------
+ // retrieve analysis manager
+ //
+
+ UInt_t trigger = triggerMask.Atoll();
+
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (!mgr) {
+ ::Error("AddAnalysisTaskD0", "No analysis manager to connect to.");
+ return NULL;
+ }
+
+ // create the task and configure
+ TString taskName = Form("D0%s%s_%.1f_%d_%.1f_%.1f_%.1f_%.1f_%.1f_%.4f_%.5f", (isPP? "pp" : "PbPb"), (isMC ? "MC" : "Data"), cutV, NTPCcluster, nsigmaTPCPi, nsigmaTPCKa, nsigmaTOFPi, nsigmaTOFKa, trackDCAcutMax, trackDCAcutMin, dcaProduct);
+ 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);
+ }
+
+ task->SelectCollisionCandidates(trigger);
+
+
+ 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("AddAnalysisTaskD0", 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;
+ if (!isPP){
+ outPlane = task->CreateOutput("eventPlane", "HIST", "EVENT");
+ outPlane->AddAxis(planeID, 180, 0.0, TMath::Pi());
+ }
+
+ TH2F* hvz=new TH2F("hVzVsCent","",100,0.,100., 220,-11.,11.);
+ task->SetEventQAHist("vz",hvz);//plugs this histogram into the fHAEventVz data member
+
+ TH2F* hmc=new TH2F("MultiVsCent","",100,0.,100.,4000,0.,4000.);
+ hmc->GetYaxis()->SetTitle("QUALITY");
+ task->SetEventQAHist("multicent",hmc);//plugs this histogram into the fHAEventMultiCent data member
+
+ TH2F* hep=new TH2F("hEventPlaneVsCent","",100,0.,100., 180,0.,TMath::Pi());
+ task->SetEventQAHist("eventplane",hep);//plugs this histogram into the fHAEventPlane data member
+
+ //
+ // -- PAIR CUTS (common to all resonances) ------------------------------------------------------
+ //
+ AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange);
+ cutY->SetRangeD(minYlab, maxYlab);
+
+ AliRsnCutMiniPair *cutDCAproduct = new AliRsnCutMiniPair("cutDCAproduct", AliRsnCutMiniPair::kDCAproduct);
+ cutDCAproduct->SetRangeD(-1E20, dcaProduct);
+
+ AliRsnCutSet *cutsPairY = new AliRsnCutSet("pairCutsY", AliRsnTarget::kMother);
+ cutsPairY->AddCut(cutY);
+ cutsPairY->UseMonitor(kTRUE);
+ cutsPairY->SetCutScheme("setPairD0_Y");
+ cutsPairY->ShowCuts();
+ cutsPairY->PrintSetInfo();
+
+ AliRsnCutSet *cutsPairDCAp = new AliRsnCutSet("pairCutsDCAp", AliRsnTarget::kMother);
+ cutsPairDCAp->AddCut(cutDCAproduct);
+ cutsPairDCAp->UseMonitor(kTRUE);
+ cutsPairDCAp->SetCutScheme("setPairD0_DCAp");
+ cutsPairDCAp->ShowCuts();
+ cutsPairDCAp->PrintSetInfo();
+
+
+ //
+ // -- CONFIG ANALYSIS --------------------------------------------------------------------------
+ gROOT->LoadMacro("$ALICE_ROOT/PWGLF/RESONANCES/macros/mini/ConfigD0.C");
+
+ if (isMC) {
+ Printf("========================== MC analysis - PID cuts not used");
+ } else
+ Printf("========================== DATA analysis - PID cuts used");
+ if (!ConfigD0(task, isPP, isMC, nsigmaTPCPi, nsigmaTPCKa, nsigmaTOFPi, nsigmaTOFKa, aodFilterBit, trackDCAcutMax, trackDCAcutMin, NTPCcluster, minpt, "", cutsPairY, cutsPairDCAp)) return 0x0;
+
+ //
+ // -- CONTAINERS --------------------------------------------------------------------------------
+ //
+ TString outputFileName = AliAnalysisManager::GetCommonFileName();
+ Printf("AddAnalysisTaskD0 - Set OutputFileName : \n %s\n", outputFileName.Data() );
+
+ AliAnalysisDataContainer *output = mgr->CreateContainer(Form("%s_%.1f_%d_%.1f_%.1f_%.1f_%.1f_%.1f_%.4f_%.5f_%.2f",outNameSuffix.Data(),cutV,NTPCcluster,nsigmaTPCPi,nsigmaTPCKa,nsigmaTOFPi,nsigmaTOFKa,trackDCAcutMax,trackDCAcutMin,dcaProduct,minpt),
+ TList::Class(),
+ AliAnalysisManager::kOutputContainer,
+ outputFileName);
+ mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
+ mgr->ConnectOutput(task, 1, output);
+
+ return task;
+}
--- /dev/null
+//
+// *** 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 ConfigD0
+(
+ AliRsnMiniAnalysisTask *task,
+ Bool_t isPP,
+ Bool_t isMC,
+ Float_t nsigmaTPCPi = 3.0,
+ Float_t nsigmaTPCKa = 3.0,
+ Float_t nsigmaTOFPi = 2.0,
+ Float_t nsigmaTOFKa = 2.0,
+ Int_t aodFilterBit = 5,
+ Float_t trackDCAcutMax = 7.0,
+ Float_t trackDCAcutMin = 0.0,
+ Int_t NTPCcluster = 70,
+ Double_t minpt = 0.15,
+ const char *suffix,
+ AliRsnCutSet *cutsPairY,
+ AliRsnCutSet *cutsPairDCAp
+)
+{
+ // manage suffix
+ if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
+
+ TString s = ""; s+=trackDCAcutMax; s+="*(0.0015+0.0050/pt^1.01)";
+
+ const char *formula = s;
+
+ TString s2 = ""; s2+=trackDCAcutMin; s2+="*(0.0015+0.0050/pt^1.01)";
+
+ const char *formula2 = s2;
+
+
+ //
+ // -- Define track cuts -------------------------------------------------------------------------
+ //
+
+ // integrated pion cut
+ AliRsnCutDaughterD0 *cutPi = new AliRsnCutDaughterD0("cutPionForD0", AliPID::kPion);
+ cutPi->SetTPCPionPIDCut(nsigmaTPCPi);
+ cutPi->SetTOFPionPIDCut(nsigmaTOFPi);
+ AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutPi->CutQuality();
+ cutQuality->SetCheckOnlyFilterBit(kFALSE);
+ cutQuality->SetAODTestFilterBit(aodFilterBit);
+ cutQuality->SetDCARPtFormula(formula);
+ //cutQuality->SetDCARPtFormula2(formula2);
+ cutQuality->SetDCARmin(trackDCAcutMin);
+ cutQuality->SetTPCminNClusters(NTPCcluster);
+ cutQuality->SetPtRange(minpt,1E20);
+ cutQuality->SetEtaRange(-0.8, 0.8);
+ cutQuality->SetDCAZmax(2.0);
+ cutQuality->SetSPDminNClusters(1);
+ cutQuality->SetITSminNClusters(0);
+ cutQuality->SetITSmaxChi2(1E+20);
+ cutQuality->SetTPCmaxChi2(4.0);
+ cutQuality->SetRejectKinkDaughters();
+ cutQuality->Print();
+
+
+
+ // cut set
+ AliRsnCutSet *cutSetPi = new AliRsnCutSet("setPionD0", AliRsnTarget::kDaughter);
+ cutSetPi->AddCut(cutPi);
+ cutSetPi->SetCutScheme(cutPi->GetName());
+ // add to task
+ Int_t iCutPi = task->AddTrackCuts(cutSetPi);
+
+
+
+ // integrated kaon cut
+ AliRsnCutDaughterD0 *cutK = new AliRsnCutDaughterD0("cutKaonForD0", AliPID::kKaon);
+ cutK->SetTPCKaonPIDCut(nsigmaTPCKa);
+ cutK->SetTOFKaonPIDCut(nsigmaTOFKa);
+ AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutK->CutQuality();
+ cutQuality->SetCheckOnlyFilterBit(kFALSE);
+ cutQuality->SetAODTestFilterBit(aodFilterBit);
+ cutQuality->SetDCARPtFormula(formula);
+ //cutQuality->SetDCARPtFormula2(formula2);
+ cutQuality->SetDCARmin(trackDCAcutMin);
+ cutQuality->SetTPCminNClusters(NTPCcluster);
+ cutQuality->SetPtRange(minpt,1E20);
+ cutQuality->SetEtaRange(-0.8, 0.8);
+ cutQuality->SetDCAZmax(2.0);
+ cutQuality->SetSPDminNClusters(1);
+ cutQuality->SetITSminNClusters(0);
+ cutQuality->SetITSmaxChi2(1E+20);
+ cutQuality->SetTPCmaxChi2(4.0);
+ cutQuality->SetRejectKinkDaughters();
+ cutQuality->Print();
+
+
+
+ // cut set
+ AliRsnCutSet *cutSetK = new AliRsnCutSet("setKaonD0", 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);
+ /* pseudorapidity */ Int_t etaID = task->CreateValue(AliRsnMiniValue::kEta, kFALSE);
+ /* rapidity */ Int_t yID = task->CreateValue(AliRsnMiniValue::kY, kFALSE);
+ /* dca product */ Int_t dcapID = task->CreateValue(AliRsnMiniValue::kDCAproduct, kFALSE);
+ /* first daughter pt */ Int_t daug1ptID = task->CreateValue(AliRsnMiniValue::kFirstDaughterPt, kFALSE);
+ /* second daughter pt */ Int_t daug2ptID = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kFALSE);
+ /* first daughter dca */ Int_t daug1dcaID = task->CreateValue(AliRsnMiniValue::kFirstDaughterDCA, kFALSE);
+ /* second daughter dca*/ Int_t daug2dcaID = task->CreateValue(AliRsnMiniValue::kSecondDaughterDCA, 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 [14] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , isMC , isMC , isMC , isMC };
+ Bool_t useIM [14] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 };
+ TString name [14] = {"Unlike1", "Unlike2", "Mixing1", "Mixing2", "RotateK1", "RotateP1", "RotateK2", "RotateP2", "LikePP" , "LikeMM" , "Trues1" , "Trues2" , "Res1" , "Res2" };
+ TString comp [14] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "ROTATE1" , "ROTATE2" , "ROTATE1" , "ROTATE2" , "PAIR" , "PAIR" , "TRUE" , "TRUE" , "TRUE" , "TRUE" };
+ TString output [14] = {"SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" };
+ Char_t charge1 [14] = {'+' , '-' , '+' , '-' , '+' , '+' , '-' , '-' , '+' , '-' , '+' , '-' , '+' , '-' };
+ Char_t charge2 [14] = {'-' , '+' , '-' , '+' , '-' , '-' , '+' , '+' , '+' , '-' , '-' , '+' , '-' , '+' };
+ Int_t cutID1 [14] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK };
+ Int_t cutID2 [14] = { iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi };
+ Int_t ipdg [14] = { 421 , -421 , 421 , -421 , 421 , 421 , -421 , -421 , 421 , -421 , 421 , -421 , 421 , -421 };
+ Double_t mass [14] = { 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 , 1.86486 };
+
+ for (Int_t i = 0; i < 14; i++) {
+ if (!use[i]) continue;
+
+ // create output
+ AliRsnMiniOutput *out = task->CreateOutput(Form("D0_%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(ipdg[i]);
+ out->SetMotherMass(mass[i]);
+ // pair cuts
+ out->SetPairCuts(cutsPairY);
+ out->SetPairCuts(cutsPairDCAp);
+
+ // axis X: invmass (or resolution)
+ if (useIM[i])
+ out->AddAxis(imID, 800, 1.4, 2.2);
+ else
+ out->AddAxis(resID, 200, -0.02, 0.02);
+ // axis Y: transverse momentum
+ out->AddAxis(ptID, 100, 0.0, 10.0);
+
+ // axiz Z: rapidity
+ out->AddAxis(yID, 100, -1, 1);
+
+ // more axis: daughter's dca product
+ out->AddAxis(dcapID, 2000, -0.001, 0.001);
+
+ out->AddAxis(daug1ptID, 1500, 0.0, 15.0);
+
+ out->AddAxis(daug2ptID, 1500, 0.0, 15.0);
+
+ out->AddAxis(daug1dcaID, 1000, -1.0, 1.0);
+
+ out->AddAxis(daug2dcaID, 1000, -1.0, 1.0);
+
+
+ if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
+ }
+
+
+ AddMonitorOutput_PairY(cutsPairY->GetMonitorOutput());
+ AddMonitorOutput_PairDCAProduct(cutsPairDCAp->GetMonitorOutput());
+
+ AddMonitorOutput_PionEta(cutSetPi->GetMonitorOutput());
+ AddMonitorOutput_PionY(cutSetPi->GetMonitorOutput());
+ AddMonitorOutput_PionMinPt(cutSetPi->GetMonitorOutput());
+ AddMonitorOutput_PionDCA(cutSetPi->GetMonitorOutput());
+ AddMonitorOutput_PionTPC_PIDCut(cutSetPi->GetMonitorOutput());
+ AddMonitorOutput_PionTOF_PIDCut(cutSetPi->GetMonitorOutput());
+ AddMonitorOutput_PionNTPC(cutSetPi->GetMonitorOutput());
+
+ AddMonitorOutput_KaonEta(cutSetK->GetMonitorOutput());
+ AddMonitorOutput_KaonY(cutSetK->GetMonitorOutput());
+ AddMonitorOutput_KaonMinPt(cutSetK->GetMonitorOutput());
+ AddMonitorOutput_KaonDCA(cutSetK->GetMonitorOutput());
+ AddMonitorOutput_KaonTPC_PIDCut(cutSetK->GetMonitorOutput());
+ AddMonitorOutput_KaonTOF_PIDCut(cutSetK->GetMonitorOutput());
+ AddMonitorOutput_KaonNTPC(cutSetK->GetMonitorOutput());
+
+
+
+ if (isMC) {
+
+ TString mode = "SPARSE";
+
+ // create output
+ AliRsnMiniOutput *out = task->CreateOutput(Form("D0_TrueMC%s", suffix), mode.Data(), "MOTHER");
+ // selection settings
+ out->SetDaughter(0, AliRsnDaughter::kKaon);
+ out->SetDaughter(1, AliRsnDaughter::kPion);
+ out->SetMotherPDG(421);
+ out->SetMotherMass(1.86486);
+ // pair cuts
+ out->SetPairCuts(cutsPairY);
+ // binnings
+ out->AddAxis(imID, 800, 1.4, 2.2);
+ out->AddAxis(ptID, 100, 0.0, 10.0);
+ out->AddAxis(yID, 100, -1, 1);
+
+ if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
+
+ // create output
+ AliRsnMiniOutput *out = task->CreateOutput(Form("D0bar_TrueMC%s", suffix), mode.Data(), "MOTHER");
+ // selection settings
+ out->SetDaughter(0, AliRsnDaughter::kKaon);
+ out->SetDaughter(1, AliRsnDaughter::kPion);
+ out->SetMotherPDG(-421);
+ out->SetMotherMass(1.86486);
+ // pair cuts
+ out->SetPairCuts(cutsPairY);
+ // binnings
+ out->AddAxis(imID, 800, 1.4, 2.2);
+ out->AddAxis(ptID, 100, 0.0, 10.0);
+ out->AddAxis(yID, 100, -1, 1);
+
+ if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
+
+
+ }
+
+ return kTRUE;
+}
+
+void AddMonitorOutput_PairY(TObjArray *mon=0,TString opt="",AliRsnLoopPair *pairy=0)
+{
+
+ // Pair Y
+ AliRsnValuePair *axisPairY = new AliRsnValuePair("pair_y", AliRsnValuePair::kY);
+ axisPairY->SetBins(-1.0,1.0,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPairY = new AliRsnListOutput("Pair_Y", AliRsnListOutput::kHistoDefault);
+ outMonitorPairY->AddValue(axisPairY);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPairY);
+ if (pairy) pairy->AddOutput(outMonitorPairY);
+
+}
+
+void AddMonitorOutput_PairDCAProduct(TObjArray *mon=0,TString opt="",AliRsnLoopPair*pairdcaproduct=0)
+{
+
+ // Pair DCA Product
+ AliRsnValuePair *axisPairDCAProduct = new AliRsnValuePair("pair_dcaproduct", AliRsnValuePair::kDCAproduct);
+ axisPairDCAProduct->SetBins(-1.0,1.0,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPairDCAProduct = new AliRsnListOutput("Pair_DCAProduct", AliRsnListOutput::kHistoDefault);
+ outMonitorPairDCAProduct->AddValue(axisPairDCAProduct);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPairDCAProduct);
+ if (pairdcaproduct) pairdcaproduct->AddOutput(outMonitorPairDCAProduct);
+
+}
+
+
+void AddMonitorOutput_PionEta(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *peta=0)
+{
+
+ // PionEta
+ AliRsnValueDaughter *axisPionEta = new AliRsnValueDaughter("pion_eta", AliRsnValueDaughter::kEta);
+ axisPionEta->SetBins(-1.0,1.0,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionEta = new AliRsnListOutput("Pion_Eta", AliRsnListOutput::kHistoDefault);
+ outMonitorPionEta->AddValue(axisPionEta);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionEta);
+ if (peta) peta->AddOutput(outMonitorPionEta);
+
+}
+
+void AddMonitorOutput_PionY(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *py=0)
+{
+
+ // PionY
+ AliRsnValueDaughter *axisPionY = new AliRsnValueDaughter("pion_y", AliRsnValueDaughter::kY);
+ axisPionY->SetBins(-1.0,1.0,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionY = new AliRsnListOutput("Pion_Y", AliRsnListOutput::kHistoDefault);
+ outMonitorPionY->AddValue(axisPionY);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionY);
+ if (py) py->AddOutput(outMonitorPionY);
+
+}
+
+void AddMonitorOutput_PionMinPt(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *pmpt=0)
+{
+
+ // PionMinPt
+ AliRsnValueDaughter *axisPionMinPt = new AliRsnValueDaughter("pion_minpt", AliRsnValueDaughter::kPt);
+ axisPionMinPt->SetBins(0.0,1,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionMinPt = new AliRsnListOutput("Pion_MinPt", AliRsnListOutput::kHistoDefault);
+ outMonitorPionMinPt->AddValue(axisPionMinPt);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionMinPt);
+ if (pmpt) pmpt->AddOutput(outMonitorPionMinPt);
+
+}
+
+void AddMonitorOutput_PionDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *pdca=0)
+{
+
+ // PionDCA
+ AliRsnValueDaughter *axisPionDCA = new AliRsnValueDaughter("pion_dca", AliRsnValueDaughter::kDCAXY);
+ axisPionDCA->SetBins(0.0,1,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionDCA = new AliRsnListOutput("Pion_DCA", AliRsnListOutput::kHistoDefault);
+ outMonitorPionDCA->AddValue(axisPionDCA);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionDCA);
+ if (pdca) pdca->AddOutput(outMonitorPionDCA);
+
+}
+
+void AddMonitorOutput_PionTPC_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piTPCPID=0)
+{
+
+ // Pion PID Cut
+ AliRsnValueDaughter *axisPionTPCPIDCut = new AliRsnValueDaughter("pionTPCPID", AliRsnValueDaughter::kTPCnsigmaPi);
+ axisPionTPCPIDCut->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionTPCPIDCut = new AliRsnListOutput("Pion_TPC_PID_Cut", AliRsnListOutput::kHistoDefault);
+ outMonitorPionTPCPIDCut->AddValue(axisPionTPCPIDCut);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionTPCPIDCut);
+ if (piTPCPID) piTPCPID->AddOutput(outMonitorPionPIDCut);
+
+}
+
+void AddMonitorOutput_PionTOF_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piTOFPID=0)
+{
+
+ // Pion PID Cut
+ AliRsnValueDaughter *axisPionTOFPIDCut = new AliRsnValueDaughter("pionTOFPID", AliRsnValueDaughter::kTOFnsigmaPi);
+ axisPionTOFPIDCut->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionTOFPIDCut = new AliRsnListOutput("Pion_TOF_PID_Cut", AliRsnListOutput::kHistoDefault);
+ outMonitorPionTOFPIDCut->AddValue(axisPionTOFPIDCut);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionTOFPIDCut);
+ if (piTOFPID) piTOFPID->AddOutput(outMonitorPionTOFPIDCut);
+
+}
+
+void AddMonitorOutput_PionNTPC(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piNTPC=0)
+{
+
+ // Pion PID Cut
+ AliRsnValueDaughter *axisPionNTPC = new AliRsnValueDaughter("pionNTPC", AliRsnValueDaughter::kNTPCclusters);
+ axisPionNTPC->SetBins(0.0,200,1);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorPionNTPC = new AliRsnListOutput("Pion_NTPC", AliRsnListOutput::kHistoDefault);
+ outMonitorPionNTPC->AddValue(axisPionNTPC);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorPionNTPC);
+ if (piNTPC) pNTPC->AddOutput(outMonitorPionNTPC);
+
+}
+
+void AddMonitorOutput_KaonEta(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *keta=0)
+{
+
+ // KaonEta
+ AliRsnValueDaughter *axisKaonEta = new AliRsnValueDaughter("kaon_eta", AliRsnValueDaughter::kEta);
+ axisKaonEta->SetBins(-1.0,1.0,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorKaonEta = new AliRsnListOutput("Kaon_Eta", AliRsnListOutput::kHistoDefault);
+ outMonitorKaonEta->AddValue(axisKaonEta);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorKaonEta);
+ if (keta) keta->AddOutput(outMonitorKaonEta);
+
+}
+
+void AddMonitorOutput_KaonY(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ky=0)
+{
+
+ // KaonY
+ AliRsnValueDaughter *axisKaonY = new AliRsnValueDaughter("kaon_y", AliRsnValueDaughter::kY);
+ axisKaonY->SetBins(-1.0,1.0,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorKaonY = new AliRsnListOutput("Kaon_Y", AliRsnListOutput::kHistoDefault);
+ outMonitorKaonY->AddValue(axisKaonY);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorKaonY);
+ if (ky) ky->AddOutput(outMonitorKaonY);
+
+}
+
+void AddMonitorOutput_KaonMinPt(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kmpt=0)
+{
+
+ // KaonMinPt
+ AliRsnValueDaughter *axisKaonMinPt = new AliRsnValueDaughter("kaon_minpt", AliRsnValueDaughter::kPt);
+ axisKaonMinPt->SetBins(0.0,1,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorKaonMinPt = new AliRsnListOutput("Kaon_MinPt", AliRsnListOutput::kHistoDefault);
+ outMonitorKaonMinPt->AddValue(axisKaonMinPt);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorKaonMinPt);
+ if (kmpt) kmpt->AddOutput(outMonitorKaonMinPt);
+
+}
+
+void AddMonitorOutput_KaonDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kdca=0)
+{
+
+ // KaonDCA
+ AliRsnValueDaughter *axisKaonDCA = new AliRsnValueDaughter("kaon_dca", AliRsnValueDaughter::kDCAXY);
+ axisKaonDCA->SetBins(0.0,1,0.001);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorKaonDCA = new AliRsnListOutput("Kaon_DCA", AliRsnListOutput::kHistoDefault);
+ outMonitorKaonDCA->AddValue(axisKaonDCA);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorKaonDCA);
+ if (kdca) kdca->AddOutput(outMonitorKaonDCA);
+
+}
+
+void AddMonitorOutput_KaonTPC_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kTPCPID=0)
+{
+
+ // Kaon TPC PID Cut
+ AliRsnValueDaughter *axisKaonTPCPIDCut = new AliRsnValueDaughter("kaonTPCPID", AliRsnValueDaughter::kTPCnsigmaK);
+ axisKaonTPCPIDCut->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorKaonTPCPIDCut = new AliRsnListOutput("Kaon_TPC_PID_Cut", AliRsnListOutput::kHistoDefault);
+ outMonitorKaonTPCPIDCut->AddValue(axisKaonTPCPIDCut);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorKaonTPCPIDCut);
+ if (kTPCPID) kTPCPID->AddOutput(outMonitorKaonTPCPIDCut);
+
+}
+
+void AddMonitorOutput_KaonTOF_PIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kTOFPID=0)
+{
+
+ // Kaon TOF PID Cut
+ AliRsnValueDaughter *axisKaonTOFPIDCut = new AliRsnValueDaughter("kaonTOFPID", AliRsnValueDaughter::kTOFnsigmaK);
+ axisKaonTOFPIDCut->SetBins(0.0,5,0.01);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorKaonTOFPIDCut = new AliRsnListOutput("Kaon_TOF_PID_Cut", AliRsnListOutput::kHistoDefault);
+ outMonitorKaonTOFPIDCut->AddValue(axisKaonTOFPIDCut);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorKaonTOFPIDCut);
+ if (kTOFPID) kTOFPID->AddOutput(outMonitorKaonTOFPIDCut);
+
+}
+
+void AddMonitorOutput_KaonNTPC(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *kNTPC=0)
+{
+
+ // Kaon PID Cut
+ AliRsnValueDaughter *axisKaonNTPC = new AliRsnValueDaughter("kaonNTPC", AliRsnValueDaughter::kNTPCclusters);
+ axisKaonNTPC->SetBins(0.0,200,1);
+
+ // output: 2D histogram
+ AliRsnListOutput *outMonitorKaonNTPC = new AliRsnListOutput("Kaon_NTPC", AliRsnListOutput::kHistoDefault);
+ outMonitorKaonNTPC->AddValue(axisKaonNTPC);
+
+ // add outputs to loop
+ if (mon) mon->Add(outMonitorKaonNTPC);
+ if (kNTPC) kNTPC->AddOutput(outMonitorKaonNTPC);
+
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff