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);
}
