void AddPairOutputRho(AliRsnLoopPair *pair) { Bool_t valid; Int_t isFullOutput = AliAnalysisManager::GetGlobalInt("rsnOutputFull",valid); // axes AliRsnValuePair *axisIM = new AliRsnValuePair("IM", AliRsnValuePair::kInvMass); AliRsnValuePair *axisPt = new AliRsnValuePair("PT", AliRsnValuePair::kPt); AliRsnValuePair *axisEta = new AliRsnValuePair("ETA", AliRsnValuePair::kEta); axisIM ->SetBins(1000, 0.2, 1.2); // axisIM ->SetBins(1000, 0.9, 1.9); axisPt ->SetBins(120, 0.0, 12.0); axisEta ->SetBins(400, -2.0, 2.0); // output: 2D histogram of inv. mass vs. pt AliRsnListOutput *outPair = 0; if (!isFullOutput) { outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoDefault); outPair->AddValue(axisIM); } else { outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoSparse); outPair->AddValue(axisIM); outPair->AddValue(axisPt); outPair->AddValue(axisEta); } // add outputs to loop pair->AddOutput(outPair); }
void AddMonitorOutput_LambdaRadius(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ldca=0) { // Lambda Radius AliRsnValueDaughter *axisLambdaRadius = new AliRsnValueDaughter("lambda_radius", AliRsnValueDaughter::kV0Radius); axisLambdaRadius->SetBins(0.0,200,0.2); // output: 2D histogram AliRsnListOutput *outMonitorLambdaRadius = new AliRsnListOutput("Lambda_Radius", AliRsnListOutput::kHistoDefault); outMonitorLambdaRadius->AddValue(axisLambdaRadius); // add outputs to loop if (mon) mon->Add(outMonitorLambdaRadius); if (ldca) ldca->AddOutput(outMonitorLambdaRadius); }
void AddMonitorOutput_LambdaDCA(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ldca=0) { // Lambda DCA AliRsnValueDaughter *axisLambdaDCA = new AliRsnValueDaughter("lambda_dca", AliRsnValueDaughter::kV0DCA); axisLambdaDCA->SetBins(0.0,0.4,0.001); // output: 2D histogram AliRsnListOutput *outMonitorLambdaDCA = new AliRsnListOutput("Lambda_DCA", AliRsnListOutput::kHistoDefault); outMonitorLambdaDCA->AddValue(axisLambdaDCA); // add outputs to loop if (mon) mon->Add(outMonitorLambdaDCA); if (ldca) ldca->AddOutput(outMonitorLambdaDCA); }
void AddMonitorOutput(AliRsnLoopDaughter *mon) { // axes AliRsnValueStd *axisMomTPC = new AliRsnValueStd("pTPC", AliRsnValueStd::kTrackPtpc , 0.0, 5.0, 0.01 ); AliRsnValueStd *axisSigTPC = new AliRsnValueStd("sTPC", AliRsnValueStd::kTrackTPCsignal, 0.0, 500.0, 2.0 ); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitor = new AliRsnListOutput("mon", AliRsnListOutput::kHistoDefault); outMonitor->AddValue(axisMomTPC); outMonitor->AddValue(axisSigTPC); // add outputs to loop mon->AddOutput(outMonitor); }
void AddPairOutput(AliRsnLoopPair *pair) { // axes AliRsnValueStd *axisIM = new AliRsnValueStd("IM", AliRsnValueStd::kPairInvMass, 0.9, 1.4, 0.001); AliRsnValueStd *axisPt = new AliRsnValueStd("PT", AliRsnValueStd::kPairPt , 0.0, 5.0, 0.1 ); // output: 2D histogram of inv. mass vs. pt // AliRsnListOutput *outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoDefault); AliRsnListOutput *outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoSparse); outPair->AddValue(axisIM); outPair->AddValue(axisPt); // add outputs to loop pair->AddOutput(outPair); }
void AddMonitorOutput_LambdaAntiPionPID(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lapiPID=0) { // Lambda Cosine of the Pointing Angle AliRsnValueDaughter *axisLambdaAntiPionPID = new AliRsnValueDaughter("lambda_antipionPID", AliRsnValueDaughter::kAntiLambdaAntiPionPIDCut); axisLambdaAntiPionPID->SetBins(0.0,5,0.01); // output: 2D histogram AliRsnListOutput *outMonitorLambdaAntiPionPID = new AliRsnListOutput("Lambda_AntiPionPID", AliRsnListOutput::kHistoDefault); outMonitorLambdaAntiPionPID->AddValue(axisLambdaAntiPionPID); // add outputs to loop if (mon) mon->Add(outMonitorLambdaAntiPionPID); if (lapiPID) lpiPID->AddOutput(outMonitorLambdaAntiPionPID); }
void AddMonitorOutput_LambdaCosPointAngle(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lcpa=0) { // Lambda Cosine of the Pointing Angle AliRsnValueDaughter *axisLambdaCPA = new AliRsnValueDaughter("lambda_cospointang", AliRsnValueDaughter::kCosPointAng); axisLambdaCPA->SetBins(0.97,1.,0.0001); // output: 2D histogram AliRsnListOutput *outMonitorLambdaCPA = new AliRsnListOutput("Lambda_CosineOfPointingAngle", AliRsnListOutput::kHistoDefault); outMonitorLambdaCPA->AddValue(axisLambdaCPA); // add outputs to loop if (mon) mon->Add(outMonitorLambdaCPA); if (lcpa) lcpa->AddOutput(outMonitorLambdaCPA); }
void AddMonitorOutput_LambdaMass(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lm=0) { // Mass AliRsnValueDaughter *axisMass = new AliRsnValueDaughter("lambda_mass", AliRsnValueDaughter::kV0Mass); axisMass->SetBins(0.4,0.6,0.001); // output: 2D histogram AliRsnListOutput *outMonitorM = new AliRsnListOutput("Lambda_Mass", AliRsnListOutput::kHistoDefault); outMonitorM->AddValue(axisMass); // add outputs to loop if (mon) mon->Add(outMonitorM); if (lm) lm->AddOutput(outMonitorM); }
void AddMonitorOutput_LambdaP(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lp=0) { // Mass AliRsnValueDaughter *axisLambdaP = new AliRsnValueDaughter("lambda_momentum", AliRsnValueDaughter::kP); axisLambdaP->SetBins(0.,15.,0.001); // output: 2D histogram AliRsnListOutput *outMonitorMom = new AliRsnListOutput("Lambda_Momentum", AliRsnListOutput::kHistoDefault); outMonitorMom->AddValue(axisLambdaP); // add outputs to loop if (mon) mon->Add(outMonitorMom); if (lp) lp->AddOutput(outMonitorMom); }
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_PionPIDCut(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *piPID=0) { // Pion PID Cut AliRsnValueDaughter *axisPionPIDCut = new AliRsnValueDaughter("pionPID", AliRsnValueDaughter::kTPCnsigmaPi); axisPionPIDCut->SetBins(0.0,5,0.01); // output: 2D histogram AliRsnListOutput *outMonitorPionPIDCut = new AliRsnListOutput("Pion_PID_Cut", AliRsnListOutput::kHistoDefault); outMonitorPionPIDCut->AddValue(axisPionPIDCut); // add outputs to loop if (mon) mon->Add(outMonitorPionPIDCut); if (piPID) piPID->AddOutput(outMonitorPionPIDCut); }
void AddMonitorOutput_PionDCAz(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *pdcaz=0) { // PionDCA AliRsnValueDaughter *axisPionDCAz = new AliRsnValueDaughter("pion_dcaz", AliRsnValueDaughter::kDCAZ); axisPionDCAz->SetBins(-2.5,2.5,0.005); // output: 2D histogram AliRsnListOutput *outMonitorPionDCAz = new AliRsnListOutput("Pion_DCAz", AliRsnListOutput::kHistoDefault); outMonitorPionDCAz->AddValue(axisPionDCAz); // add outputs to loop if (mon) mon->Add(outMonitorPionDCAz); if (pdcaz) pdcaz->AddOutput(outMonitorPionDCAz); }
void AddMonitorOutput_PionEta(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *peta=0) { // PionDCA AliRsnValueDaughter *axisPionEta = new AliRsnValueDaughter("pion_eta", AliRsnValueDaughter::kEta); axisPionEta->SetBins(-2.,2.,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_PionPt(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *ppt=0) { // PionDCA AliRsnValueDaughter *axisPionPt = new AliRsnValueDaughter("pion_pt", AliRsnValueDaughter::kPt); axisPionPt->SetBins(0.,10.0,0.001); // output: 2D histogram AliRsnListOutput *outMonitorPionPt = new AliRsnListOutput("Pion_Pt", AliRsnListOutput::kHistoDefault); outMonitorPionPt->AddValue(axisPionPt); // add outputs to loop if (mon) mon->Add(outMonitorPionPt); if (ppt) ppt->AddOutput(outMonitorPionPt); }
void AddMonitorOutput_LambdaPosDaughPt(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lppt=0) { // Mass AliRsnValueDaughter *axisLambdaPosDaughPt = new AliRsnValueDaughter("lambda_posdaugh_transversemomentum", AliRsnValueDaughter::kV0PPt); axisLambdaPosDaughPt->SetBins(0.,15.,0.001); // output: 2D histogram AliRsnListOutput *outMonitorLambdaPosDaughTrMom = new AliRsnListOutput("Lambda_PosDaugh_TransverseMomentum", AliRsnListOutput::kHistoDefault); outMonitorLambdaPosDaughTrMom->AddValue(axisLambdaPosDaughPt); // add outputs to loop if (mon) mon->Add(outMonitorLambdaPosDaughTrMom); if (lppt) lppt->AddOutput(outMonitorLambdaPosDaughTrMom); }
// // Test config macro for RSN package. // It configures: // 1) a monitor for all tracks passing quality cuts // 2) a monitor for all tracks passing quality + PID cuts // 3) an unlike-sign invariant-mass + pt distribution for K+K- pairs // Bool_t RsnConfigPhiKaonTest ( AliRsnAnalysisTask *task, Bool_t isMC ) { if (!task) { ::Error("RsnConfigPhiKaonTest.C", "NULL task"); return kFALSE; } const char *suffix = "test"; // ---------------------------------------------------------------------------------------------- // -- DEFINITIONS ------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------- // daughter definition for monitor loops // since it is intended to loop over all 'track' like objects (in the sense that we exclude V0s and cascades), // we initialize it using the constructor that requires an AliRsnDaughter::EType and a charge, but since // we want to loop over both charges, we set it to anything which is not '+' '-' or '0', which are tokens for // selecting only positive, only negative or only neutral AliRsnDaughterDef *tracks = new AliRsnDaughterDef(AliRsnDaughter::kTrack, 0); // definition of pair decay tree for phi resonance // here we *must* specify a particle species and a charge, in order to check the decay tree // last arguments are the PDG code and nominal mass of the resonance, which are needed when // one wants to select true pairs only and/or he wants to compute rapidity or Mt AliRsnPairDef *pairDef = new AliRsnPairDef(AliRsnDaughter::kKaon, '+', AliRsnDaughter::kKaon, '-', 333, 1.019455); // definition of loop objects: // (a) 1 monitor for all tracks passing quality cuts // (b) 1 monitor for all tracks passing quality+PID cuts // (c) 1 pair filled with all tracks passing same cuts as (b) // (d) 1 pair like (c) but for mixing // (e) 1 pair like (c) but with true pairs only // NOTE: (c) and (d) are instantiated with same settings, they will be made // different after some settings done in second moment AliRsnLoopDaughter *loopQuality = new AliRsnLoopDaughter(Form("%s_mon_quality", suffix), 0, tracks); AliRsnLoopDaughter *loopPID = new AliRsnLoopDaughter(Form("%s_mon_pid" , suffix), 0, tracks); AliRsnLoopPair *loopPhi = new AliRsnLoopPair (Form("%s_unlike" , suffix), pairDef); AliRsnLoopPair *loopPhiMix = new AliRsnLoopPair (Form("%s_unlike" , suffix), pairDef); AliRsnLoopPair *loopPhiTrue = new AliRsnLoopPair (Form("%s_trues" , suffix), pairDef); // set additional option for true pairs (slot [0]) loopPhiTrue->SetOnlyTrue(kTRUE); loopPhiTrue->SetCheckDecay(kTRUE); // set mixing options loopPhi ->SetMixed(kFALSE); loopPhiMix ->SetMixed(kTRUE); loopPhiTrue->SetMixed(kFALSE); // assign the ID of the entry lists to be used by each pair to get selected daughters // in our case, the AliRsnInputHandler contains only one list for selecting kaons Int_t idQuality, idPID; AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); AliMultiInputEventHandler *multi = dynamic_cast<AliMultiInputEventHandler*>(mgr->GetInputEventHandler()); if (!multi) { myError("Needed a multi input handler!"); return kFALSE; } TObjArray *array = multi->InputEventHandlers(); AliRsnInputHandler *rsn = (AliRsnInputHandler*)array->FindObject("rsnInputHandler"); if (!rsn) { myError("Needed an RSN event handler"); return kFALSE; } AliRsnDaughterSelector *sel = rsn->GetSelector(); idQuality = sel->GetID("qualityTPC", kTRUE); idPID = sel->GetID("kaonTPC", kTRUE); if (idQuality < 0 || idPID < 0) { myError("List problems"); return kFALSE; } loopQuality->SetListID(idQuality); loopPID ->SetListID(idPID); loopPhi ->SetListID(0, idPID); loopPhi ->SetListID(1, idPID); loopPhiMix ->SetListID(0, idPID); loopPhiMix ->SetListID(1, idPID); loopPhiTrue->SetListID(0, idPID); loopPhiTrue->SetListID(1, idPID); // ---------------------------------------------------------------------------------------------- // -- EVENT CUTS -------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------- // primary vertex: // - 2nd argument --> |Vz| range // - 3rd argument --> minimum required number of contributors // - 4th argument --> tells if TPC stand-alone vertexes must be accepted // we switch on the check for pileup AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE); cutVertex->SetCheckPileUp(kTRUE); // primary vertex is always used AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent); eventCuts->AddCut(cutVertex); eventCuts->SetCutScheme(cutVertex->GetName()); // add the event cuts to all loops loopQuality->SetEventCuts(eventCuts); loopPID ->SetEventCuts(eventCuts); loopPhi ->SetEventCuts(eventCuts); loopPhi ->SetEventCuts(eventCuts); loopPhiMix ->SetEventCuts(eventCuts); loopPhiMix ->SetEventCuts(eventCuts); loopPhiTrue->SetEventCuts(eventCuts); loopPhiTrue->SetEventCuts(eventCuts); // ---------------------------------------------------------------------------------------------- // -- PAIR CUTS --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------- // for pairs we define a rapidity windows, defined through a cut // --> NOTE: it needs a support AliRsnPairDef from which it takes the mass AliRsnValueStd *valRapidity = new AliRsnValueStd("valY", AliRsnValueStd::kPairY); AliRsnCutValue *cutRapidity = new AliRsnCutValue("cutY", -0.5, 0.5, isMC); valRapidity->SetSupportObject(pairDef); cutRapidity->SetValueObj(valRapidity); // cut set AliRsnCutSet *pairCuts = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother); pairCuts->AddCut(cutRapidity); pairCuts->SetCutScheme(cutRapidity->GetName()); // add cut to pair loops only loopPhi ->SetPairCuts(pairCuts); loopPhi ->SetPairCuts(pairCuts); loopPhiMix ->SetPairCuts(pairCuts); loopPhiMix ->SetPairCuts(pairCuts); loopPhiTrue->SetPairCuts(pairCuts); loopPhiTrue->SetPairCuts(pairCuts); // ---------------------------------------------------------------------------------------------- // -- COMPUTED VALUES & OUTPUTS ----------------------------------------------------------------- // ---------------------------------------------------------------------------------------------- AliRsnValueStd *axisIM = new AliRsnValueStd("IM" , AliRsnValueStd::kPairInvMass , 0.9, 1.4, 0.001); AliRsnValueStd *axisPt = new AliRsnValueStd("PT" , AliRsnValueStd::kPairPt , 0.0, 5.0, 0.1 ); AliRsnValueStd *axisMomTPC = new AliRsnValueStd("pTPC", AliRsnValueStd::kTrackPtpc , 0.0, 5.0, 0.01 ); AliRsnValueStd *axisSigTPC = new AliRsnValueStd("sTPC", AliRsnValueStd::kTrackTPCsignal, 0.0, 500.0, 2.0 ); // output for monitors: // 2D histogram with TPC signal vs TPC momentum AliRsnListOutput *outMonitor = new AliRsnListOutput("mon", AliRsnListOutput::kHistoDefault); outMonitor->AddValue(axisMomTPC); outMonitor->AddValue(axisSigTPC); // output for pairs: // 2D histogram with inv.mass vs pt AliRsnListOutput *outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoDefault); outPair->AddValue(axisIM); outPair->AddValue(axisPt); // add outputs to loops loopQuality->AddOutput(outMonitor); loopPID ->AddOutput(outMonitor); loopPhi ->AddOutput(outPair); loopPhiMix ->AddOutput(outPair); loopPhiTrue->AddOutput(outPair); // ---------------------------------------------------------------------------------------------- // -- CONCLUSION -------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------------------- task->Add(loopQuality); task->Add(loopPID ); task->Add(loopPhi ); task->Add(loopPhiMix ); task->Add(loopPhiTrue); return kTRUE; }
void AddMonitorOutput(TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lm=0) { Bool_t valid; Int_t useMCMon = AliAnalysisManager::GetGlobalInt("rsnUseMCMonitoring",valid); // if (useMCMon) return; // dEdx tpc AliRsnValueDaughter *axisMomTPC = new AliRsnValueDaughter("pTPC", AliRsnValueDaughter::kPtpc); AliRsnValueDaughter *axisSigTPC = new AliRsnValueDaughter("sTPC", AliRsnValueDaughter::kTPCsignal); //axisMomTPC->SetBins(0.0,5.0,0.01); axisMomTPC->SetBins(0.0,12.0,0.05); axisSigTPC->SetBins(0.0,500.0,2.0); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitordEdxTPC = new AliRsnListOutput("dEdx", AliRsnListOutput::kHistoDefault); outMonitordEdxTPC->AddValue(axisMomTPC); outMonitordEdxTPC->AddValue(axisSigTPC); // add outputs to loop if (mon) mon->Add(outMonitordEdxTPC); if (lm) lm->AddOutput(outMonitordEdxTPC); // dEdx tpc AliRsnValueDaughter *axisMomTPCForTOF = new AliRsnValueDaughter("pTPC", AliRsnValueDaughter::kPtpc); AliRsnValueDaughter *axisSigTOF = new AliRsnValueDaughter("sTOF", AliRsnValueDaughter::kTOFsignal); //axisMomTPCForTOF->SetBins(0.0,5.0,0.01); //axisSigTOF->SetBins(0.0,500.0,2.0); axisMomTPCForTOF->SetBins(0.0,12.0,0.05); axisSigTOF->SetBins(0.0,5.e5,1.e3); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitordEdxTOF = new AliRsnListOutput("TOF", AliRsnListOutput::kHistoDefault); outMonitordEdxTOF->AddValue(axisMomTPCForTOF); outMonitordEdxTOF->AddValue(axisSigTOF); // add outputs to loop if (mon) mon->Add(outMonitordEdxTOF); if (lm) lm->AddOutput(outMonitordEdxTOF); // Momentum AliRsnValueDaughter *axisMomP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kP); //axisMomP->SetBins(0.0,5.0,0.01); axisMomP->SetBins(0.0,12.0,0.05); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorP = new AliRsnListOutput("P", AliRsnListOutput::kHistoDefault); outMonitorP->AddValue(axisMomP); // add outputs to loop if (mon) mon->Add(outMonitorP); if (lm) lm->AddOutput(outMonitorP); if (useMCMon) { AliRsnValueDaughter *axisMomPMC = new AliRsnValueDaughter("pMC", AliRsnValueDaughter::kP); axisMomPMC->SetUseMCInfo(kTRUE); //axisMomPMC->SetBins(0.0,5.0,0.01); axisMomPMC->SetBins(0.0,12.0,0.05); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorPMC = new AliRsnListOutput("PMC", AliRsnListOutput::kHistoDefault); outMonitorPMC->AddValue(axisMomPMC); // add outputs to loop if (mon) mon->Add(outMonitorPMC); if (lm) lm->AddOutput(outMonitorPMC); } // Momentum Pt AliRsnValueDaughter *axisMomPt = new AliRsnValueDaughter("pt", AliRsnValueDaughter::kPt); //axisMomPt->SetBins(0.0,5.0,0.01); axisMomPt->SetBins(0.0,12.0,0.05); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorPt = new AliRsnListOutput("Pt", AliRsnListOutput::kHistoDefault); outMonitorPt->AddValue(axisMomPt); // add outputs to loop if (mon) mon->Add(outMonitorPt); if (lm) lm->AddOutput(outMonitorPt); if (useMCMon) { // Momentum Pt AliRsnValueDaughter *axisMomPtMC = new AliRsnValueDaughter("ptMC", AliRsnValueDaughter::kPt); axisMomPtMC->SetUseMCInfo(kTRUE); //axisMomPtMC->SetBins(0.0,5.0,0.01); axisMomPtMC->SetBins(0.0,12.0,0.05); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorPtMC = new AliRsnListOutput("PtMC", AliRsnListOutput::kHistoDefault); outMonitorPtMC->AddValue(axisMomPtMC); // add outputs to loop if (mon) mon->Add(outMonitorPtMC); if (lm) lm->AddOutput(outMonitorPtMC); } // Eta AliRsnValueDaughter *axisMomEta = new AliRsnValueDaughter("eta", AliRsnValueDaughter::kEta); axisMomEta->SetBins(-1.0,1.0,0.01); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorEta = new AliRsnListOutput("Eta", AliRsnListOutput::kHistoDefault); outMonitorEta->AddValue(axisMomEta); // add outputs to loop if (mon) mon->Add(outMonitorEta); if (lm) lm->AddOutput(outMonitorEta); if (useMCMon) { // Eta AliRsnValueDaughter *axisMomEtaMC = new AliRsnValueDaughter("etaMC", AliRsnValueDaughter::kEta); axisMomEtaMC->SetUseMCInfo(kTRUE); axisMomEtaMC->SetBins(-1.0,1.0,0.01); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorEtaMC = new AliRsnListOutput("EtaMC", AliRsnListOutput::kHistoDefault); outMonitorEtaMC->AddValue(axisMomEtaMC); // add outputs to loop if (mon) mon->Add(outMonitorEtaMC); if (lm) lm->AddOutput(outMonitorEtaMC); } AliRsnValueDaughter *axisPtBig = new AliRsnValueDaughter("pt", AliRsnValueDaughter::kPt); axisPtBig->SetBins(0.0,12.0,0.5); // kTOFnsigmaK AliRsnValueDaughter *axisTPCnsigmaK = new AliRsnValueDaughter("K", AliRsnValueDaughter::kTPCnsigmaK); axisTPCnsigmaK->SetBins(1001,-100,100); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorTPCnsigmaK = new AliRsnListOutput("TPC_nsigma", AliRsnListOutput::kHistoDefault); outMonitorTPCnsigmaK->AddValue(axisTPCnsigmaK); outMonitorTPCnsigmaK->AddValue(axisPtBig); // add outputs to loop if (mon) mon->Add(outMonitorTPCnsigmaK); if (lm) lm->AddOutput(outMonitorTPCnsigmaK); // kTPCnsigmaPi AliRsnValueDaughter *axisTPCnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTPCnsigmaPi); axisTPCnsigmaPi->SetBins(1001,-100,100); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorTPCnsigmaPi = new AliRsnListOutput("TPC_nsigma", AliRsnListOutput::kHistoDefault); outMonitorTPCnsigmaPi->AddValue(axisTPCnsigmaPi); outMonitorTPCnsigmaPi->AddValue(axisPtBig); // add outputs to loop if (mon) mon->Add(outMonitorTPCnsigmaPi); if (lm) lm->AddOutput(outMonitorTPCnsigmaPi); // kTPCnsigmaP AliRsnValueDaughter *axisTPCnsigmaP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kTPCnsigmaP); axisTPCnsigmaP->SetBins(1001,-100,100); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorTPCnsigmaP = new AliRsnListOutput("TPC_nsigma", AliRsnListOutput::kHistoDefault); outMonitorTPCnsigmaP->AddValue(axisTPCnsigmaP); outMonitorTPCnsigmaP->AddValue(axisPtBig); // add outputs to loop if (mon) mon->Add(outMonitorTPCnsigmaP); if (lm) lm->AddOutput(outMonitorTPCnsigmaP); if (!opt.Contains("NoTOFSIGMA")) { // kTOFnsigmaK AliRsnValueDaughter *axisTOFnsigmaK = new AliRsnValueDaughter("K", AliRsnValueDaughter::kTOFnsigmaK); axisTOFnsigmaK->SetBins(1001,-100,100); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorTOFnsigmaK = new AliRsnListOutput("TOF_nsigma", AliRsnListOutput::kHistoDefault); outMonitorTOFnsigmaK->AddValue(axisTOFnsigmaK); outMonitorTOFnsigmaK->AddValue(axisPtBig); // add outputs to loop if (mon) mon->Add(outMonitorTOFnsigmaK); if (lm) lm->AddOutput(outMonitorTOFnsigmaK); // kTOFnsigmaPi AliRsnValueDaughter *axisTOFnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTOFnsigmaPi); axisTOFnsigmaPi->SetBins(1001,-100,100); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorTOFnsigmaPi = new AliRsnListOutput("TOF_nsigma", AliRsnListOutput::kHistoDefault); outMonitorTOFnsigmaPi->AddValue(axisTOFnsigmaPi); outMonitorTOFnsigmaPi->AddValue(axisPtBig); // add outputs to loop if (mon) mon->Add(outMonitorTOFnsigmaPi); if (lm) lm->AddOutput(outMonitorTOFnsigmaPi); // kTOFnsigmaP AliRsnValueDaughter *axisTOFnsigmaP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kTOFnsigmaP); axisTOFnsigmaP->SetBins(1001,-100,100); // output: 2D histogram of TPC signal vs. TPC momentum AliRsnListOutput *outMonitorTOFnsigmaP = new AliRsnListOutput("TOF_nsigma", AliRsnListOutput::kHistoDefault); outMonitorTOFnsigmaP->AddValue(axisTOFnsigmaP); outMonitorTOFnsigmaP->AddValue(axisPtBig); // add outputs to loop if (mon) mon->Add(outMonitorTOFnsigmaP); if (lm) lm->AddOutput(outMonitorTOFnsigmaP); } // nITCcluster AliRsnValueDaughter *axisITSnClusters = new AliRsnValueDaughter("ITS", AliRsnValueDaughter::kNITSclusters); axisITSnClusters->SetBins(10,0,10); AliRsnListOutput *outMonitorITSnClusters = new AliRsnListOutput("nClusters", AliRsnListOutput::kHistoDefault); outMonitorITSnClusters->AddValue(axisITSnClusters); // add outputs to loop if (mon) mon->Add(outMonitorITSnClusters); if (lm) lm->AddOutput(outMonitorITSnClusters); // nTPCcluster AliRsnValueDaughter *axisTPCnClusters = new AliRsnValueDaughter("TPC", AliRsnValueDaughter::kNTPCclusters); axisTPCnClusters->SetBins(300,0,300); AliRsnListOutput *outMonitorTPCnClusters = new AliRsnListOutput("nClusters", AliRsnListOutput::kHistoDefault); outMonitorTPCnClusters->AddValue(axisTPCnClusters); // add outputs to loop if (mon) mon->Add(outMonitorTPCnClusters); if (lm) lm->AddOutput(outMonitorTPCnClusters); // ITSchi2 AliRsnValueDaughter *axisITSchi2 = new AliRsnValueDaughter("ITS", AliRsnValueDaughter::kITSchi2); axisITSchi2->SetBins(10,0,10); AliRsnListOutput *outMonitorITSchi2 = new AliRsnListOutput("chi2", AliRsnListOutput::kHistoDefault); outMonitorITSchi2->AddValue(axisITSchi2); // add outputs to loop if (mon) mon->Add(outMonitorITSchi2); if (lm) lm->AddOutput(outMonitorITSchi2); // TPCchi2 AliRsnValueDaughter *axisTPCchi2 = new AliRsnValueDaughter("TPC", AliRsnValueDaughter::kTPCchi2); axisTPCchi2->SetBins(10,0,10); AliRsnListOutput *outMonitorTPCchi2 = new AliRsnListOutput("chi2", AliRsnListOutput::kHistoDefault); outMonitorTPCchi2->AddValue(axisTPCchi2); // add outputs to loop if (mon) mon->Add(outMonitorTPCchi2); if (lm) lm->AddOutput(outMonitorTPCchi2); // DCAXY AliRsnValueDaughter *axisDCAXY = new AliRsnValueDaughter("XY", AliRsnValueDaughter::kDCAXY); axisDCAXY->SetBins(200,-1,1); AliRsnListOutput *outMonitorDCAXY = new AliRsnListOutput("DCA", AliRsnListOutput::kHistoDefault); outMonitorDCAXY->AddValue(axisDCAXY); // add outputs to loop if (mon) mon->Add(outMonitorDCAXY); if (lm) lm->AddOutput(outMonitorDCAXY); // DCAZ AliRsnValueDaughter *axisDCAZ = new AliRsnValueDaughter("Z", AliRsnValueDaughter::kDCAZ); axisDCAZ->SetBins(200,-1,1); AliRsnListOutput *outMonitorDCAZ = new AliRsnListOutput("DCA", AliRsnListOutput::kHistoDefault); outMonitorDCAZ->AddValue(axisDCAZ); // add outputs to loop if (mon) mon->Add(outMonitorDCAZ); if (lm) lm->AddOutput(outMonitorDCAZ); AliRsnListOutput *outMonitorPTvsMult = new AliRsnListOutput("PTvsMult",AliRsnListOutput::kHistoDefault); AliRsnValueDaughter *vd1 = new AliRsnValueDaughter("pt",AliRsnValueDaughter::kPt); vd1->SetBins(0.0,5.0,0.01); outMonitorPTvsMult->AddValue(vd1); AliRsnValueEvent *ve1 = new AliRsnValueEvent("mult",AliRsnValueEvent::kMult); ve1->SetBins(0.0,100.0,1); outMonitorPTvsMult->AddValue(ve1); if (mon) mon->Add(outMonitorPTvsMult); if (lm) lm->AddOutput(outMonitorPTvsMult); // AliRsnListOutput *outMonitorMult = new AliRsnListOutput("EventMult",AliRsnListOutput::kHistoDefault); // // AliRsnValueEvent *ve1Multi = new AliRsnValueEvent("centrality",AliRsnValueEvent::kCentralityV0); // ve1Multi->SetBins(0.0,100,10.0); // outMonitorMult->AddValue(ve1Multi); // if (mon) mon->Add(outMonitorMult); // if (lm) lm->AddOutput(outMonitorMult); }