[u/mrichter/AliRoot.git] / PWGLF / RESONANCES / macros / mini / AddMonitorOutput.C

/***************************************************************************
              fbellini@cern.ch - last modified on 06/08/2012

 Macro to add monitoring histograms for track and PID cuts to the rsn task 
 Tuned for monitoring TOF KStar analysis of PbPb 2010 data
/***************************************************************************/


void AddMonitorOutput(Bool_t useMCMon = 0, TObjArray *mon=0,TString opt="",AliRsnLoopDaughter *lm=0)
{
  
  // Multiplicity/centrality
  AliRsnValueEvent *multi = new AliRsnValueEvent("multi",AliRsnValueEvent::kMult);
  multi->SetBins(0.0, 400.0, 1);
  // Momentum
  AliRsnValueDaughter *axisMomTPC = new AliRsnValueDaughter("pTPC", AliRsnValueDaughter::kPtpc);
  axisMomTPC->SetBins(0.0, 10.0, 0.01);
  AliRsnValueDaughter *axisMomP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kP);
  axisMomP->SetBins(0.0, 10.0, 0.01);
  // Momentum Pt
  AliRsnValueDaughter *axisMomPt = new AliRsnValueDaughter("pt", AliRsnValueDaughter::kPt);
  axisMomPt->SetBins(0.0,10.0,0.01);
  // Eta
  AliRsnValueDaughter *axisMomEta = new AliRsnValueDaughter("eta", AliRsnValueDaughter::kEta);
  axisMomEta->SetBins(-1.0, 1.0, 0.1);
  //ITS clusters
  AliRsnValueDaughter *axisITScls = new AliRsnValueDaughter("ITScls", AliRsnValueDaughter::kNITSclusters);
  axisITScls->SetBins(0.0, 10.0, 1.0);
  //TPC clusters
  AliRsnValueDaughter *axisTPCcls = new AliRsnValueDaughter("TPCcls", AliRsnValueDaughter::kNTPCclusters);
  axisTPCcls->SetBins(0.0, 300.0, 1.0);
  //ITS chi2
  AliRsnValueDaughter *axisITSchi2 = new AliRsnValueDaughter("ITSchi2", AliRsnValueDaughter::kITSchi2);
  axisITSchi2->SetBins(0.0, 10.0, 0.1);
  //TPC chi2
  AliRsnValueDaughter *axisTPCchi2 = new AliRsnValueDaughter("TPCchi2", AliRsnValueDaughter::kTPCchi2);
  axisTPCchi2->SetBins(0.0, 10.0, 0.1);
  //DCA xy
  AliRsnValueDaughter *axisDCAxy = new AliRsnValueDaughter("DCAxy", AliRsnValueDaughter::kDCAXY);
  axisDCAxy->SetBins(-2.0, 2.0, 0.1);
  //DCA z
  AliRsnValueDaughter *axisDCAz = new AliRsnValueDaughter("DCAz", AliRsnValueDaughter::kDCAZ);
  axisDCAz->SetBins(-10.0, 10.0, 0.1);

  /* dEdx tpc */
  AliRsnValueDaughter *axisSigTPC = new AliRsnValueDaughter("sTPC", AliRsnValueDaughter::kTPCsignal);
  axisSigTPC->SetBins(0.0, 500.0, 2.0);
  // kTPCnsigmaPi
  AliRsnValueDaughter *axisTPCnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTPCnsigmaPi);
  axisTPCnsigmaPi->SetBins(-10.,10., 0.1);
  // kTPCnsigmaK
  AliRsnValueDaughter *axisTPCnsigmaK = new AliRsnValueDaughter("K", AliRsnValueDaughter::kTPCnsigmaK);
  axisTPCnsigmaK->SetBins(-10.,10., 0.1);
  // kTPCnsigmaP
  AliRsnValueDaughter *axisTPCnsigmaP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kTPCnsigmaP);
  axisTPCnsigmaP->SetBins(-10.,10., 0.1);

  /* tof signal - time */
  AliRsnValueDaughter *axisSigTOF = new AliRsnValueDaughter("sTOF", AliRsnValueDaughter::kTOFsignal);
  axisSigTOF->SetBins(10000.0, 50000.0, 250);//in ps
  // kTOFnsigmaPi
  AliRsnValueDaughter *axisTOFnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTOFnsigmaPi);
  axisTOFnsigmaPi->SetBins(-10.,10., 0.1);
  // kTOFnsigmaK
  AliRsnValueDaughter *axisTOFnsigmaK = new AliRsnValueDaughter("K", AliRsnValueDaughter::kTOFnsigmaK);
  axisTOFnsigmaK->SetBins(-10.,10., 0.1);
  // kTOFnsigmaP
  AliRsnValueDaughter *axisTOFnsigmaP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kTOFnsigmaP);
  axisTOFnsigmaP->SetBins(-10.,10., 0.1);
   
  /****************************************************************/
  /***************       MONITOR AOB           ********************/
  /****************************************************************/
  AliRsnListOutput *outMonitorPTvsMult = new AliRsnListOutput("PtVsMult",AliRsnListOutput::kHistoDefault);
  outMonitorPTvsMult->AddValue(axisMomPt);
  outMonitorPTvsMult->AddValue(multi);
  if (mon) mon->Add(outMonitorPTvsMult);
  if (lm) lm->AddOutput(outMonitorPTvsMult);

  //    if (lm) lm->SetTrueMC(kTRUE);
  /****************************************************************/
  /***************       MONITOR kinematics    ********************/
  /****************************************************************/
  // output: TH1D for momentum
  AliRsnListOutput *outMonitorP = new AliRsnListOutput("P", AliRsnListOutput::kHistoDefault);
  outMonitorP->AddValue(axisMomP);
  if (mon) mon->Add(outMonitorP);
  if (lm) lm->AddOutput(outMonitorP);

  // output:  TH1D for pt
  AliRsnListOutput *outMonitorPt = new AliRsnListOutput("Pt", AliRsnListOutput::kHistoDefault);
  outMonitorPt->AddValue(axisMomPt);
  if (mon) mon->Add(outMonitorPt);
  if (lm) lm->AddOutput(outMonitorPt);

  // output: TH1D for pseudorapidity
  AliRsnListOutput *outMonitorEta = new AliRsnListOutput("Eta", AliRsnListOutput::kHistoDefault);
  outMonitorEta->AddValue(axisMomEta);
  if (mon) mon->Add(outMonitorEta);
  if (lm) lm->AddOutput(outMonitorEta);

  /****************************************************************/
  /***************      MONITOR TRACK QUALITY  ********************/
  /****************************************************************/
  // output: 2D histogram of DCAxy vs pt
  AliRsnListOutput *outMonitorDCAxy = new AliRsnListOutput("DCAxyVsPt", AliRsnListOutput::kHistoDefault);
  outMonitorDCAxy->AddValue(axisMomPt);
  outMonitorDCAxy->AddValue(axisDCAxy);
  if (mon) mon->Add(outMonitorDCAxy);
  if (lm) lm->AddOutput(outMonitorDCAxy);

  // output: 2D histogram of DCAz vs P
  AliRsnListOutput *outMonitorDCAz = new AliRsnListOutput("DCAzVsP", AliRsnListOutput::kHistoDefault);
  outMonitorDCAz->AddValue(axisMomP);
  outMonitorDCAz->AddValue(axisDCAz);
  if (mon) mon->Add(outMonitorDCAz);
  if (lm) lm->AddOutput(outMonitorDCAz);

  // output: 2D histogram of ITS cls vs pt
  AliRsnListOutput *outMonitorITScls = new AliRsnListOutput("ITSclsVsPt", AliRsnListOutput::kHistoDefault);
  outMonitorITScls->AddValue(axisMomPt);
  outMonitorITScls->AddValue(axisITScls);
  if (mon) mon->Add(outMonitorITScls);
  if (lm) lm->AddOutput(outMonitorITScls);

  // output: 2D histogram of TPC cls vs. pt
  AliRsnListOutput *outMonitorTPCcls = new AliRsnListOutput("TPCclsVsPt", AliRsnListOutput::kHistoDefault);
  outMonitorTPCcls->AddValue(axisMomPt);
  outMonitorTPCcls->AddValue(axisTPCcls);
  if (mon) mon->Add(outMonitorTPCcls);
  if (lm) lm->AddOutput(outMonitorTPCcls);

// output: 2D histogram of TPC cls vs. TPC momentum
  AliRsnListOutput *outMonitorTPCclsVsPtpc = new AliRsnListOutput("TPCclsVsPtpc", AliRsnListOutput::kHistoDefault);
  outMonitorTPCclsVsPtpc->AddValue(axisMomTPC);
  outMonitorTPCclsVsPtpc->AddValue(axisTPCcls);
  if (mon) mon->Add(outMonitorTPCclsVsPtpc);
  if (lm) lm->AddOutput(outMonitorTPCclsVsPtpc);

 // output: 2D histogram of ITS chi2 vs pt
  AliRsnListOutput *outMonitorITSchi2 = new AliRsnListOutput("ITSchi2VsPt", AliRsnListOutput::kHistoDefault);
  outMonitorITSchi2->AddValue(axisMomPt);
  outMonitorITSchi2->AddValue(axisITSchi2);
  if (mon) mon->Add(outMonitorITSchi2);
  if (lm) lm->AddOutput(outMonitorITSchi2);

  // output: 2D histogram of TPC chi2 vs. pt
  AliRsnListOutput *outMonitorTPCchi2 = new AliRsnListOutput("TPCchi2VsPt", AliRsnListOutput::kHistoDefault);
  outMonitorTPCchi2->AddValue(axisMomPt);
  outMonitorTPCchi2->AddValue(axisTPCchi2);
  if (mon) mon->Add(outMonitorTPCchi2);
  if (lm) lm->AddOutput(outMonitorTPCchi2);

// output: 2D histogram of TPC chi2 vs. TPC momentum
  AliRsnListOutput *outMonitorTPCchi2VsPtpc = new AliRsnListOutput("TPCchi2VsPtpc", AliRsnListOutput::kHistoDefault);
  outMonitorTPCchi2VsPtpc->AddValue(axisMomTPC);
  outMonitorTPCchi2VsPtpc->AddValue(axisTPCchi2);
  if (mon) mon->Add(outMonitorTPCchi2VsPtpc);
  if (lm) lm->AddOutput(outMonitorTPCchi2VsPtpc);

  /****************************************************************/
  /***************       MONITOR TPC           ********************/
  /****************************************************************/
  // output: 2D histogram of TPC signal vs. TPC momentum
  AliRsnListOutput *outMonitordEdxTPC = new AliRsnListOutput("dEdx_VsPtpc", AliRsnListOutput::kHistoDefault);
  outMonitordEdxTPC->AddValue(axisMomTPC);
  outMonitordEdxTPC->AddValue(axisSigTPC);
  if (mon) mon->Add(outMonitordEdxTPC);
  if (lm) lm->AddOutput(outMonitordEdxTPC);

  // output: 2D histogram of TPC nsigma pi vs. TPC momentum
  AliRsnListOutput *outMonitorTPCnsigmaPi = new AliRsnListOutput("TPC_nsigmaPi_VsPtpc", AliRsnListOutput::kHistoDefault);
  outMonitorTPCnsigmaPi->AddValue(axisMomTPC);
  outMonitorTPCnsigmaPi->AddValue(axisTPCnsigmaPi);
  if (mon) mon->Add(outMonitorTPCnsigmaPi);
  if (lm) lm->AddOutput(outMonitorTPCnsigmaPi);

  // output: 2D histogram of TPC nsigma K vs. TPC momentum
  AliRsnListOutput *outMonitorTPCnsigmaK = new AliRsnListOutput("TPC_nsigmaK_VsPtpc", AliRsnListOutput::kHistoDefault);
  outMonitorTPCnsigmaK->AddValue(axisMomTPC);
  outMonitorTPCnsigmaK->AddValue(axisTPCnsigmaK);
  if (mon) mon->Add(outMonitorTPCnsigmaK);
  if (lm) lm->AddOutput(outMonitorTPCnsigmaK);

  // output: 2D histogram of TPC nsigma pro vs. TPC momentum
  AliRsnListOutput *outMonitorTPCnsigmaP = new AliRsnListOutput("TPC_nsigmaPro_VsPtpc", AliRsnListOutput::kHistoDefault);
  outMonitorTPCnsigmaP->AddValue(axisMomTPC);
  outMonitorTPCnsigmaP->AddValue(axisTPCnsigmaP);
  if (mon) mon->Add(outMonitorTPCnsigmaP);
  if (lm) lm->AddOutput(outMonitorTPCnsigmaP);

  /****************************************************************/
  /***************       MONITOR TOF           ********************/
  /****************************************************************/
  // output: 2D histogram of TOF signal vs. momentum
  AliRsnListOutput *outMonitorTimeTOF = new AliRsnListOutput("time_VsP", AliRsnListOutput::kHistoDefault);
  outMonitorTimeTOF->AddValue(axisMomP);
  outMonitorTimeTOF->AddValue(axisSigTOF);
  if (mon) mon->Add(outMonitorTimeTOF);
  if (lm) lm->AddOutput(outMonitorTimeTOF);

  // output: 2D histogram of TOF signal vs. pt
  AliRsnListOutput *outMonitorTimeTOFPt = new AliRsnListOutput("time_VsPt", AliRsnListOutput::kHistoDefault);
  outMonitorTimeTOFPt->AddValue(axisMomPt);
  outMonitorTimeTOFPt->AddValue(axisSigTOF);
  if (mon) mon->Add(outMonitorTimeTOFPt);
  if (lm) lm->AddOutput(outMonitorTimeTOFPt);

  if (!opt.Contains("NoTOFSIGMA")) {
    // output: 2D histogram of TOF Nsigma pi vs. TPC momentum
    AliRsnListOutput *outMonitorTOFnsigmaPi = new AliRsnListOutput("TOF_nsigmaPi_vsP", AliRsnListOutput::kHistoDefault);
    outMonitorTOFnsigmaPi->AddValue(axisMomP);
    outMonitorTOFnsigmaPi->AddValue(axisTOFnsigmaPi);
    if (mon) mon->Add(outMonitorTOFnsigmaPi);
    if (lm) lm->AddOutput(outMonitorTOFnsigmaPi);
     
    // output: 2D histogram of TOF signal vs. TOF momentum
    AliRsnListOutput *outMonitorTOFnsigmaK = new AliRsnListOutput("TOF_nsigmaK_vsP", AliRsnListOutput::kHistoDefault);
    outMonitorTOFnsigmaK->AddValue(axisMomP);
    outMonitorTOFnsigmaK->AddValue(axisTOFnsigmaK);
    if (mon) mon->Add(outMonitorTOFnsigmaK);
    if (lm) lm->AddOutput(outMonitorTOFnsigmaK);
      
    // output: 2D histogram of TOF signal vs. TOF momentum
    AliRsnListOutput *outMonitorTOFnsigmaP = new AliRsnListOutput("TOF_nsigmaPro_vsP", AliRsnListOutput::kHistoDefault);
    outMonitorTOFnsigmaP->AddValue(axisMomP);
    outMonitorTOFnsigmaP->AddValue(axisTOFnsigmaP);
    if (mon) mon->Add(outMonitorTOFnsigmaP);
    if (lm) lm->AddOutput(outMonitorTOFnsigmaP);
  }

  /****************************************************************/
  /***************       MONITOR MC            ********************/
  /****************************************************************/
  if (useMCMon) {
    //Momentum 
    AliRsnValueDaughter *axisMomPMC = new AliRsnValueDaughter("pMC", AliRsnValueDaughter::kP);
    axisMomPMC->SetUseMCInfo(kTRUE);
    axisMomPMC->SetBins(0.0,10.0,0.01);
    // Momentum Pt
    AliRsnValueDaughter *axisMomPtMC = new AliRsnValueDaughter("ptMC", AliRsnValueDaughter::kPt);
    axisMomPtMC->SetUseMCInfo(kTRUE);
    axisMomPtMC->SetBins(0.0,10.0,0.01);
    // Eta
    AliRsnValueDaughter *axisEtaMC = new AliRsnValueDaughter("etaMC", AliRsnValueDaughter::kEta);
    axisEtaMC->SetUseMCInfo(kTRUE);
    axisEtaMC->SetBins(-1.0,1.0,0.1);

    // output: 2D histo for kine acceptance
    AliRsnListOutput *outMonitorPtVsEtaMC = new AliRsnListOutput("Pt_VsEtaMC", AliRsnListOutput::kHistoDefault);
    outMonitorPtVsEtaMC->AddValue(axisMomPtMC);
    outMonitorPtVsEtaMC->AddValue(axisEtaMC);
    if (mon) mon->Add(outMonitorPtVsEtaMC);
    if (lm) lm->AddOutput(outMonitorPtVsEtaMC);

    // output: 1D histo pt from MC
    AliRsnListOutput *outMonitorPtMC = new AliRsnListOutput("PtMC", AliRsnListOutput::kHistoDefault);
    outMonitorPtMC->AddValue(axisMomPtMC);
    if (mon) mon->Add(outMonitorPtMC);
    if (lm) lm->AddOutput(outMonitorPtMC);
 
    // output: 1D histo eta from MC
    AliRsnListOutput *outMonitorEtaMC = new AliRsnListOutput("EtaMC", AliRsnListOutput::kHistoDefault);
    outMonitorEtaMC->AddValue(axisEtaMC);
    if (mon) mon->Add(outMonitorEtaMC);
    if (lm) lm->AddOutput(outMonitorEtaMC);

    // output: 1D histo pt from MC
    AliRsnListOutput *outMonitorPtMC = new AliRsnListOutput("PtMC", AliRsnListOutput::kHistoDefault);
    outMonitorPtMC->AddValue(axisMomPtMC);
    if (mon) mon->Add(outMonitorPtMC);
    if (lm) lm->AddOutput(outMonitorPtMC);
  }
 
}
Commit	Line	Data
da3e2cdb	1	/***************************************************************************
	2	fbellini@cern.ch - last modified on 06/08/2012
	3
	4	Macro to add monitoring histograms for track and PID cuts to the rsn task
	5	Tuned for monitoring TOF KStar analysis of PbPb 2010 data
	6	/***************************************************************************/
	7
	8
	9	void AddMonitorOutput(Bool_t useMCMon = 0, TObjArray mon=0,TString opt="",AliRsnLoopDaughter lm=0)
	10	{
	11
	12	// Multiplicity/centrality
	13	AliRsnValueEvent *multi = new AliRsnValueEvent("multi",AliRsnValueEvent::kMult);
58a1c9a4	14	multi->SetBins(0.0, 400.0, 1);
da3e2cdb	15	// Momentum
	16	AliRsnValueDaughter *axisMomTPC = new AliRsnValueDaughter("pTPC", AliRsnValueDaughter::kPtpc);
	17	axisMomTPC->SetBins(0.0, 10.0, 0.01);
	18	AliRsnValueDaughter *axisMomP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kP);
	19	axisMomP->SetBins(0.0, 10.0, 0.01);
	20	// Momentum Pt
	21	AliRsnValueDaughter *axisMomPt = new AliRsnValueDaughter("pt", AliRsnValueDaughter::kPt);
	22	axisMomPt->SetBins(0.0,10.0,0.01);
	23	// Eta
	24	AliRsnValueDaughter *axisMomEta = new AliRsnValueDaughter("eta", AliRsnValueDaughter::kEta);
58a1c9a4	25	axisMomEta->SetBins(-1.0, 1.0, 0.1);
eec5d1ed	26	//ITS clusters
	27	AliRsnValueDaughter *axisITScls = new AliRsnValueDaughter("ITScls", AliRsnValueDaughter::kNITSclusters);
	28	axisITScls->SetBins(0.0, 10.0, 1.0);
	29	//TPC clusters
	30	AliRsnValueDaughter *axisTPCcls = new AliRsnValueDaughter("TPCcls", AliRsnValueDaughter::kNTPCclusters);
	31	axisTPCcls->SetBins(0.0, 300.0, 1.0);
	32	//ITS chi2
	33	AliRsnValueDaughter *axisITSchi2 = new AliRsnValueDaughter("ITSchi2", AliRsnValueDaughter::kITSchi2);
	34	axisITSchi2->SetBins(0.0, 10.0, 0.1);
	35	//TPC chi2
	36	AliRsnValueDaughter *axisTPCchi2 = new AliRsnValueDaughter("TPCchi2", AliRsnValueDaughter::kTPCchi2);
	37	axisTPCchi2->SetBins(0.0, 10.0, 0.1);
	38	//DCA xy
	39	AliRsnValueDaughter *axisDCAxy = new AliRsnValueDaughter("DCAxy", AliRsnValueDaughter::kDCAXY);
51a8daf6	40	axisDCAxy->SetBins(-2.0, 2.0, 0.1);
eec5d1ed	41	//DCA z
eec5d1ed	42	AliRsnValueDaughter *axisDCAz = new AliRsnValueDaughter("DCAz", AliRsnValueDaughter::kDCAZ);
51a8daf6	43	axisDCAz->SetBins(-10.0, 10.0, 0.1);
da3e2cdb	44
	45	/* dEdx tpc */
	46	AliRsnValueDaughter *axisSigTPC = new AliRsnValueDaughter("sTPC", AliRsnValueDaughter::kTPCsignal);
	47	axisSigTPC->SetBins(0.0, 500.0, 2.0);
	48	// kTPCnsigmaPi
	49	AliRsnValueDaughter *axisTPCnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTPCnsigmaPi);
58a1c9a4	50	axisTPCnsigmaPi->SetBins(-10.,10., 0.1);
da3e2cdb	51	// kTPCnsigmaK
da3e2cdb	52	AliRsnValueDaughter *axisTPCnsigmaK = new AliRsnValueDaughter("K", AliRsnValueDaughter::kTPCnsigmaK);
58a1c9a4	53	axisTPCnsigmaK->SetBins(-10.,10., 0.1);
da3e2cdb	54	// kTPCnsigmaP
da3e2cdb	55	AliRsnValueDaughter *axisTPCnsigmaP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kTPCnsigmaP);
58a1c9a4	56	axisTPCnsigmaP->SetBins(-10.,10., 0.1);
da3e2cdb	57
	58	/* tof signal - time */
	59	AliRsnValueDaughter *axisSigTOF = new AliRsnValueDaughter("sTOF", AliRsnValueDaughter::kTOFsignal);
	60	axisSigTOF->SetBins(10000.0, 50000.0, 250);//in ps
	61	// kTOFnsigmaPi
	62	AliRsnValueDaughter *axisTOFnsigmaPi = new AliRsnValueDaughter("pi", AliRsnValueDaughter::kTOFnsigmaPi);
58a1c9a4	63	axisTOFnsigmaPi->SetBins(-10.,10., 0.1);
da3e2cdb	64	// kTOFnsigmaK
da3e2cdb	65	AliRsnValueDaughter *axisTOFnsigmaK = new AliRsnValueDaughter("K", AliRsnValueDaughter::kTOFnsigmaK);
58a1c9a4	66	axisTOFnsigmaK->SetBins(-10.,10., 0.1);
da3e2cdb	67	// kTOFnsigmaP
da3e2cdb	68	AliRsnValueDaughter *axisTOFnsigmaP = new AliRsnValueDaughter("p", AliRsnValueDaughter::kTOFnsigmaP);
58a1c9a4	69	axisTOFnsigmaP->SetBins(-10.,10., 0.1);
da3e2cdb	70
	71	/****************************************************************/
	72	/************* MONITOR AOB ******************/
	73	/****************************************************************/
	74	AliRsnListOutput *outMonitorPTvsMult = new AliRsnListOutput("PtVsMult",AliRsnListOutput::kHistoDefault);
	75	outMonitorPTvsMult->AddValue(axisMomPt);
	76	outMonitorPTvsMult->AddValue(multi);
	77	if (mon) mon->Add(outMonitorPTvsMult);
	78	if (lm) lm->AddOutput(outMonitorPTvsMult);
	79
	80	// if (lm) lm->SetTrueMC(kTRUE);
	81	/****************************************************************/
	82	/************* MONITOR kinematics ******************/
	83	/****************************************************************/
	84	// output: TH1D for momentum
	85	AliRsnListOutput *outMonitorP = new AliRsnListOutput("P", AliRsnListOutput::kHistoDefault);
	86	outMonitorP->AddValue(axisMomP);
	87	if (mon) mon->Add(outMonitorP);
	88	if (lm) lm->AddOutput(outMonitorP);
	89
	90	// output: TH1D for pt
	91	AliRsnListOutput *outMonitorPt = new AliRsnListOutput("Pt", AliRsnListOutput::kHistoDefault);
	92	outMonitorPt->AddValue(axisMomPt);
	93	if (mon) mon->Add(outMonitorPt);
	94	if (lm) lm->AddOutput(outMonitorPt);
	95
	96	// output: TH1D for pseudorapidity
	97	AliRsnListOutput *outMonitorEta = new AliRsnListOutput("Eta", AliRsnListOutput::kHistoDefault);
	98	outMonitorEta->AddValue(axisMomEta);
	99	if (mon) mon->Add(outMonitorEta);
	100	if (lm) lm->AddOutput(outMonitorEta);
	101
eec5d1ed	102	/****************************************************************/
	103	/************* MONITOR TRACK QUALITY ******************/
	104	/****************************************************************/
	105	// output: 2D histogram of DCAxy vs pt
	106	AliRsnListOutput *outMonitorDCAxy = new AliRsnListOutput("DCAxyVsPt", AliRsnListOutput::kHistoDefault);
	107	outMonitorDCAxy->AddValue(axisMomPt);
	108	outMonitorDCAxy->AddValue(axisDCAxy);
	109	if (mon) mon->Add(outMonitorDCAxy);
	110	if (lm) lm->AddOutput(outMonitorDCAxy);
	111
51a8daf6	112	// output: 2D histogram of DCAz vs P
eec5d1ed	113	AliRsnListOutput *outMonitorDCAz = new AliRsnListOutput("DCAzVsP", AliRsnListOutput::kHistoDefault);
	114	outMonitorDCAz->AddValue(axisMomP);
	115	outMonitorDCAz->AddValue(axisDCAz);
	116	if (mon) mon->Add(outMonitorDCAz);
	117	if (lm) lm->AddOutput(outMonitorDCAz);
	118
	119	// output: 2D histogram of ITS cls vs pt
	120	AliRsnListOutput *outMonitorITScls = new AliRsnListOutput("ITSclsVsPt", AliRsnListOutput::kHistoDefault);
	121	outMonitorITScls->AddValue(axisMomPt);
	122	outMonitorITScls->AddValue(axisITScls);
	123	if (mon) mon->Add(outMonitorITScls);
	124	if (lm) lm->AddOutput(outMonitorITScls);
	125
	126	// output: 2D histogram of TPC cls vs. pt
	127	AliRsnListOutput *outMonitorTPCcls = new AliRsnListOutput("TPCclsVsPt", AliRsnListOutput::kHistoDefault);
	128	outMonitorTPCcls->AddValue(axisMomPt);
	129	outMonitorTPCcls->AddValue(axisTPCcls);
	130	if (mon) mon->Add(outMonitorTPCcls);
	131	if (lm) lm->AddOutput(outMonitorTPCcls);
	132
	133	// output: 2D histogram of TPC cls vs. TPC momentum
	134	AliRsnListOutput *outMonitorTPCclsVsPtpc = new AliRsnListOutput("TPCclsVsPtpc", AliRsnListOutput::kHistoDefault);
	135	outMonitorTPCclsVsPtpc->AddValue(axisMomTPC);
	136	outMonitorTPCclsVsPtpc->AddValue(axisTPCcls);
	137	if (mon) mon->Add(outMonitorTPCclsVsPtpc);
	138	if (lm) lm->AddOutput(outMonitorTPCclsVsPtpc);
	139
	140	// output: 2D histogram of ITS chi2 vs pt
	141	AliRsnListOutput *outMonitorITSchi2 = new AliRsnListOutput("ITSchi2VsPt", AliRsnListOutput::kHistoDefault);
	142	outMonitorITSchi2->AddValue(axisMomPt);
	143	outMonitorITSchi2->AddValue(axisITSchi2);
	144	if (mon) mon->Add(outMonitorITSchi2);
	145	if (lm) lm->AddOutput(outMonitorITSchi2);
	146
	147	// output: 2D histogram of TPC chi2 vs. pt
	148	AliRsnListOutput *outMonitorTPCchi2 = new AliRsnListOutput("TPCchi2VsPt", AliRsnListOutput::kHistoDefault);
	149	outMonitorTPCchi2->AddValue(axisMomPt);
	150	outMonitorTPCchi2->AddValue(axisTPCchi2);
	151	if (mon) mon->Add(outMonitorTPCchi2);
	152	if (lm) lm->AddOutput(outMonitorTPCchi2);
	153
	154	// output: 2D histogram of TPC chi2 vs. TPC momentum
	155	AliRsnListOutput *outMonitorTPCchi2VsPtpc = new AliRsnListOutput("TPCchi2VsPtpc", AliRsnListOutput::kHistoDefault);
	156	outMonitorTPCchi2VsPtpc->AddValue(axisMomTPC);
	157	outMonitorTPCchi2VsPtpc->AddValue(axisTPCchi2);
	158	if (mon) mon->Add(outMonitorTPCchi2VsPtpc);
	159	if (lm) lm->AddOutput(outMonitorTPCchi2VsPtpc);
	160
da3e2cdb	161	/****************************************************************/
	162	/************* MONITOR TPC ******************/
	163	/****************************************************************/
	164	// output: 2D histogram of TPC signal vs. TPC momentum
	165	AliRsnListOutput *outMonitordEdxTPC = new AliRsnListOutput("dEdx_VsPtpc", AliRsnListOutput::kHistoDefault);
	166	outMonitordEdxTPC->AddValue(axisMomTPC);
	167	outMonitordEdxTPC->AddValue(axisSigTPC);
	168	if (mon) mon->Add(outMonitordEdxTPC);
	169	if (lm) lm->AddOutput(outMonitordEdxTPC);
	170
	171	// output: 2D histogram of TPC nsigma pi vs. TPC momentum
	172	AliRsnListOutput *outMonitorTPCnsigmaPi = new AliRsnListOutput("TPC_nsigmaPi_VsPtpc", AliRsnListOutput::kHistoDefault);
	173	outMonitorTPCnsigmaPi->AddValue(axisMomTPC);
	174	outMonitorTPCnsigmaPi->AddValue(axisTPCnsigmaPi);
	175	if (mon) mon->Add(outMonitorTPCnsigmaPi);
	176	if (lm) lm->AddOutput(outMonitorTPCnsigmaPi);
	177
	178	// output: 2D histogram of TPC nsigma K vs. TPC momentum
	179	AliRsnListOutput *outMonitorTPCnsigmaK = new AliRsnListOutput("TPC_nsigmaK_VsPtpc", AliRsnListOutput::kHistoDefault);
	180	outMonitorTPCnsigmaK->AddValue(axisMomTPC);
	181	outMonitorTPCnsigmaK->AddValue(axisTPCnsigmaK);
	182	if (mon) mon->Add(outMonitorTPCnsigmaK);
	183	if (lm) lm->AddOutput(outMonitorTPCnsigmaK);
	184
	185	// output: 2D histogram of TPC nsigma pro vs. TPC momentum
	186	AliRsnListOutput *outMonitorTPCnsigmaP = new AliRsnListOutput("TPC_nsigmaPro_VsPtpc", AliRsnListOutput::kHistoDefault);
	187	outMonitorTPCnsigmaP->AddValue(axisMomTPC);
	188	outMonitorTPCnsigmaP->AddValue(axisTPCnsigmaP);
	189	if (mon) mon->Add(outMonitorTPCnsigmaP);
	190	if (lm) lm->AddOutput(outMonitorTPCnsigmaP);
	191
	192	/****************************************************************/
	193	/************* MONITOR TOF ******************/
	194	/****************************************************************/
	195	// output: 2D histogram of TOF signal vs. momentum
	196	AliRsnListOutput *outMonitorTimeTOF = new AliRsnListOutput("time_VsP", AliRsnListOutput::kHistoDefault);
	197	outMonitorTimeTOF->AddValue(axisMomP);
	198	outMonitorTimeTOF->AddValue(axisSigTOF);
	199	if (mon) mon->Add(outMonitorTimeTOF);
	200	if (lm) lm->AddOutput(outMonitorTimeTOF);
	201
	202	// output: 2D histogram of TOF signal vs. pt
	203	AliRsnListOutput *outMonitorTimeTOFPt = new AliRsnListOutput("time_VsPt", AliRsnListOutput::kHistoDefault);
	204	outMonitorTimeTOFPt->AddValue(axisMomPt);
	205	outMonitorTimeTOFPt->AddValue(axisSigTOF);
	206	if (mon) mon->Add(outMonitorTimeTOFPt);
	207	if (lm) lm->AddOutput(outMonitorTimeTOFPt);
	208
	209	if (!opt.Contains("NoTOFSIGMA")) {
	210	// output: 2D histogram of TOF Nsigma pi vs. TPC momentum
	211	AliRsnListOutput *outMonitorTOFnsigmaPi = new AliRsnListOutput("TOF_nsigmaPi_vsP", AliRsnListOutput::kHistoDefault);
	212	outMonitorTOFnsigmaPi->AddValue(axisMomP);
	213	outMonitorTOFnsigmaPi->AddValue(axisTOFnsigmaPi);
	214	if (mon) mon->Add(outMonitorTOFnsigmaPi);
	215	if (lm) lm->AddOutput(outMonitorTOFnsigmaPi);
	216
	217	// output: 2D histogram of TOF signal vs. TOF momentum
	218	AliRsnListOutput *outMonitorTOFnsigmaK = new AliRsnListOutput("TOF_nsigmaK_vsP", AliRsnListOutput::kHistoDefault);
	219	outMonitorTOFnsigmaK->AddValue(axisMomP);
	220	outMonitorTOFnsigmaK->AddValue(axisTOFnsigmaK);
	221	if (mon) mon->Add(outMonitorTOFnsigmaK);
	222	if (lm) lm->AddOutput(outMonitorTOFnsigmaK);
	223
	224	// output: 2D histogram of TOF signal vs. TOF momentum
225	AliRsnListOutput *outMonitorTOFnsigmaP = new AliRsnListOutput("TOF_nsigmaPro_vsP", AliRsnListOutput::kHistoDefault);
226	outMonitorTOFnsigmaP->AddValue(axisMomP);
227	outMonitorTOFnsigmaP->AddValue(axisTOFnsigmaP);
228	if (mon) mon->Add(outMonitorTOFnsigmaP);
229	if (lm) lm->AddOutput(outMonitorTOFnsigmaP);
230	}
231
232	/****************************************************************/
233	/************* MONITOR MC ******************/
234	/****************************************************************/
235	if (useMCMon) {
236	//Momentum
237	AliRsnValueDaughter *axisMomPMC = new AliRsnValueDaughter("pMC", AliRsnValueDaughter::kP);
238	axisMomPMC->SetUseMCInfo(kTRUE);
239	axisMomPMC->SetBins(0.0,10.0,0.01);
240	// Momentum Pt
241	AliRsnValueDaughter *axisMomPtMC = new AliRsnValueDaughter("ptMC", AliRsnValueDaughter::kPt);
242	axisMomPtMC->SetUseMCInfo(kTRUE);
243	axisMomPtMC->SetBins(0.0,10.0,0.01);
244	// Eta
245	AliRsnValueDaughter *axisEtaMC = new AliRsnValueDaughter("etaMC", AliRsnValueDaughter::kEta);
246	axisEtaMC->SetUseMCInfo(kTRUE);
58a1c9a4	247	axisEtaMC->SetBins(-1.0,1.0,0.1);
da3e2cdb	248
	249	// output: 2D histo for kine acceptance
	250	AliRsnListOutput *outMonitorPtVsEtaMC = new AliRsnListOutput("Pt_VsEtaMC", AliRsnListOutput::kHistoDefault);
	251	outMonitorPtVsEtaMC->AddValue(axisMomPtMC);
	252	outMonitorPtVsEtaMC->AddValue(axisEtaMC);
	253	if (mon) mon->Add(outMonitorPtVsEtaMC);
	254	if (lm) lm->AddOutput(outMonitorPtVsEtaMC);
	255
	256	// output: 1D histo pt from MC
	257	AliRsnListOutput *outMonitorPtMC = new AliRsnListOutput("PtMC", AliRsnListOutput::kHistoDefault);
	258	outMonitorPtMC->AddValue(axisMomPtMC);
	259	if (mon) mon->Add(outMonitorPtMC);
	260	if (lm) lm->AddOutput(outMonitorPtMC);
	261
	262	// output: 1D histo eta from MC
	263	AliRsnListOutput *outMonitorEtaMC = new AliRsnListOutput("EtaMC", AliRsnListOutput::kHistoDefault);
	264	outMonitorEtaMC->AddValue(axisEtaMC);
	265	if (mon) mon->Add(outMonitorEtaMC);
	266	if (lm) lm->AddOutput(outMonitorEtaMC);
	267
	268	// output: 1D histo pt from MC
	269	AliRsnListOutput *outMonitorPtMC = new AliRsnListOutput("PtMC", AliRsnListOutput::kHistoDefault);
	270	outMonitorPtMC->AddValue(axisMomPtMC);
	271	if (mon) mon->Add(outMonitorPtMC);
	272	if (lm) lm->AddOutput(outMonitorPtMC);
	273	}
	274
	275	}