[u/mrichter/AliRoot.git] / PWGLF / FORWARD / analysis2 / AliAODForwardMult.cxx

//
// Class that contains the forward multiplicity data per event 
//
// This class contains a histogram of 
// @f[
//   \frac{d^2N_{ch}}{d\eta d\phi}\quad,
// @f]
// as well as a trigger mask for each analysed event.  
// 
// The eta acceptance of the event is stored in the underflow bins of
// the histogram.  So to build the final histogram, one needs to
// correct for this acceptance (properly weighted by the events), and
// the vertex efficiency.  This simply boils down to defining a 2D
// histogram and summing the event histograms in that histogram.  One
// should of course also do proper book-keeping of the accepted event.
//
#include "AliAODForwardMult.h"
#include <TBrowser.h>
#include <iostream>
#include <TMath.h>
#include <TObjString.h>
#include <TObjArray.h>
#include "AliLog.h"
ClassImp(AliAODForwardMult)
#ifdef DOXY_INPUT
; // For Emacs 
#endif

//____________________________________________________________________
const Float_t AliAODForwardMult::fgkInvalidIpZ = 1e6;

//____________________________________________________________________
AliAODForwardMult::AliAODForwardMult()
  : fIsMC(false),
    fHist(),
    fTriggers(0),
    fIpZ(fgkInvalidIpZ), 
    fCentrality(-1),				
    fNClusters(0)
{
  // 
  // Constructor 
  // 
}

//____________________________________________________________________
AliAODForwardMult::AliAODForwardMult(Bool_t isMC) 
  : fIsMC(isMC),
    fHist("forwardMult", "d^{2}N_{ch}/d#etad#varphi in the forward regions", 
	  200, -4, 6, 20, 0, 2*TMath::Pi()),
    fTriggers(0),
    fIpZ(fgkInvalidIpZ), 
    fCentrality(-1),				
    fNClusters(0)
{
  // 
  // Constructor 
  // 
  // Parameters: 
  //  isMC   If set to true this is for MC data (effects branch name)
  // 
  fHist.SetXTitle("#eta");
  fHist.SetYTitle("#varphi [radians]");
  fHist.SetZTitle("#frac{d^{2}N_{ch}}{d#etad#varphi}");
  fHist.SetDirectory(0);
  fHist.Sumw2();
}

//____________________________________________________________________
void
AliAODForwardMult::Init(const TAxis& etaAxis)
{
  // Initialize the histogram with an eta axis 
  // 
  // Parameters: 
  //   etaAxis       Eta axis to use 
  // 
  fHist.SetBins(etaAxis.GetNbins(), etaAxis.GetXmin(), etaAxis.GetXmax(), 
		20, 0, 2*TMath::Pi());
}

//____________________________________________________________________
void
AliAODForwardMult::Clear(Option_t* option)
{
  // Clear (or reset) internal values 
  // 
  // Parameters: 
  //  option   Passed to TH1::Reset 
  // 
  fHist.Reset(option);
  fTriggers  = 0;
  fIpZ       = fgkInvalidIpZ;
  fNClusters = 0;
}
//____________________________________________________________________
void
AliAODForwardMult::SetSNN(UShort_t snn)
{
  // set the center of mass energy per nucleon pair (GeV). 
  // This is stored in bin (0,0) of the histogram 
  // 
  // Parameters: 
  //   sNN   Center of mass energy per nuclean 
  fHist.SetBinContent(0,0,snn);
}
//____________________________________________________________________
void
AliAODForwardMult::SetSystem(UShort_t sys)
{
  // set the center of mass energy per nucleon pair (GeV). 
  // This is stored in bin (N+1,0) of the histogram 
  // 
  // Parameters: 
  //   sys   Collision system number 
  fHist.SetBinContent(fHist.GetNbinsX()+1,0,sys);
}

//____________________________________________________________________
Bool_t
AliAODForwardMult::HasIpZ() const
{
  // Check if we have valid z coordinate of the interaction point 
  // 
  // Return:
  //   true if the z coordinate of the interaction point is valid 
  // 
  return TMath::Abs(fIpZ - fgkInvalidIpZ) > 1;
}

//____________________________________________________________________
UShort_t
AliAODForwardMult::GetSNN() const
{
  // set the center of mass energy per nucleon pair (GeV). 
  // This is stored in bin (0,0) of the histogram 
  // 
  // Parameters: 
  //   sNN   Center of mass energy per nuclean 
  return UShort_t(fHist.GetBinContent(0,0));
}

//____________________________________________________________________
UShort_t
AliAODForwardMult::GetSystem() const
{
  // set the center of mass energy per nucleon pair (GeV). 
  // This is stored in bin (N+1,0) of the histogram 
  // 
  // Parameters: 
  //   sNN   Center of mass energy per nuclean 
  return UShort_t(fHist.GetBinContent(fHist.GetNbinsX()+1,0));
}

//____________________________________________________________________
void
AliAODForwardMult::Browse(TBrowser* b)
{
  // Browse this object 
  // 
  // Parameters: 
  //   b   Browser to use 
  static TObjString ipz;
  static TObjString trg;
  static TObjString cnt;
  static TObjString ncl;
  ipz = Form("ip_z=%fcm", fIpZ);
  trg = GetTriggerString(fTriggers);
  cnt = Form("%+6.1f%%", fCentrality);
  ncl = Form("%d clusters", fNClusters);
  b->Add(&fHist);
  b->Add(&ipz);
  b->Add(&trg);
  b->Add(&cnt);
  b->Add(&ncl);
}

namespace { 
  void AppendAnd(TString& trg, const TString& what)
  {
    if (!trg.IsNull()) trg.Append(" & ");
    trg.Append(what);
  }
}
//____________________________________________________________________
const Char_t*
AliAODForwardMult::GetTriggerString(UInt_t mask)
{
  // Get a string that describes the triggers 
  // 
  // Parameters: 
  //   mask  Bit pattern of triggers 
  // Return: 
  //   Character string representation of mask 
  static TString trg;
  trg = "";
  if ((mask & kInel)        != 0x0) AppendAnd(trg, "INEL");
  if ((mask & kInelGt0)     != 0x0) AppendAnd(trg, "INEL>0");
  if ((mask & kNSD)         != 0x0) AppendAnd(trg, "NSD");
  if ((mask & kV0AND)       != 0x0) AppendAnd(trg, "V0AND");
  if ((mask & kA)           != 0x0) AppendAnd(trg, "A");
  if ((mask & kB)           != 0x0) AppendAnd(trg, "B");
  if ((mask & kC)           != 0x0) AppendAnd(trg, "C");
  if ((mask & kE)           != 0x0) AppendAnd(trg, "E");
  if ((mask & kMCNSD)       != 0x0) AppendAnd(trg, "MCNSD");
  if ((mask & kNClusterGt0) != 0x0) AppendAnd(trg, "NCluster>0");
  if ((mask & kSatellite)   != 0x0) AppendAnd(trg, "Satellite");
  return trg.Data();
}
  
//____________________________________________________________________
TH1I*
AliAODForwardMult::MakeTriggerHistogram(const char* name, Int_t mask) 
{
  // 
  // Make a histogram to record triggers in. 
  //
  // The bins defined by the trigger enumeration in this class.  One
  // can use this enumeration to retrieve the number of triggers for
  // each class.
  // 
  // Parameters:
  //    name Name of the histogram 
  // 
  // Return:
  //    Newly allocated histogram 
  //
  TString sel("");
  TString andSel("");
  if (mask > 0) {
    sel    = GetTriggerString(mask);
    andSel = GetTriggerString(mask & ~kB);
    andSel.Prepend(" & ");
  }
  TH1I* ret = new TH1I(name, "Triggers", kAccepted+1, -.5, kAccepted+.5);
  ret->SetYTitle("Events");
  ret->SetFillColor(kRed+1);
  ret->SetFillStyle(3001);
  ret->GetXaxis()->SetBinLabel(kBinAll,         "All events");
  ret->GetXaxis()->SetBinLabel(kBinB,           Form("B (Coll.)%s", 
						     andSel.Data()));
  ret->GetXaxis()->SetBinLabel(kBinA,           Form("A%s", andSel.Data()));
  ret->GetXaxis()->SetBinLabel(kBinC,           Form("C%s", andSel.Data()));
  ret->GetXaxis()->SetBinLabel(kBinE,           Form("E%s", andSel.Data()));
  ret->GetXaxis()->SetBinLabel(kBinInel,        "Coll. & INEL");
  ret->GetXaxis()->SetBinLabel(kBinInelGt0,     "Coll. & INEL>0");
  ret->GetXaxis()->SetBinLabel(kBinNSD,         "Coll. & NSD");
  ret->GetXaxis()->SetBinLabel(kBinV0AND,       "Coll. & V0AND");
  ret->GetXaxis()->SetBinLabel(kBinMCNSD,       "NSD (MC truth)");
  ret->GetXaxis()->SetBinLabel(kBinSatellite,   "Satellite");
  ret->GetXaxis()->SetBinLabel(kBinPileUp,      "w/Pileup");
  ret->GetXaxis()->SetBinLabel(kBinOffline,     "w/Offline");
  ret->GetXaxis()->SetBinLabel(kBinNClusterGt0, "w/N_{cluster}>1");
  ret->GetXaxis()->SetBinLabel(kWithVertex,     "w/Vertex");
  ret->GetXaxis()->SetBinLabel(kWithTrigger,    Form("w/Selected trigger (%s)",
						     sel.Data()));
  ret->GetXaxis()->SetBinLabel(kAccepted,       "Accepted by cut");
  ret->GetXaxis()->SetNdivisions(kAccepted, false);
  ret->SetStats(0);

  return ret;
}
//____________________________________________________________________
UInt_t 
AliAODForwardMult::MakeTriggerMask(const char* what)
{
  UShort_t    trgMask = 0;
  TString     trgs(what);
  trgs.ToUpper();
  TObjArray*  parts = trgs.Tokenize("&");
  TObjString* trg;
  TIter       next(parts);
  while ((trg = static_cast<TObjString*>(next()))) { 
    TString s(trg->GetString());
    s.Strip(TString::kBoth, ' ');
    s.ToUpper();
    if      (s.IsNull()) continue;
    if      (s.CompareTo("INEL")  == 0) trgMask |=AliAODForwardMult::kInel;
    else if (s.CompareTo("INEL>0")== 0) trgMask |=AliAODForwardMult::kInelGt0;
    else if (s.CompareTo("NSD")   == 0) trgMask |=AliAODForwardMult::kNSD;
    else if (s.CompareTo("V0AND") == 0) trgMask |=AliAODForwardMult::kV0AND;
    else if (s.CompareTo("MCNSD") == 0) trgMask |=AliAODForwardMult::kMCNSD;
    else if (s.CompareTo("B")     == 0) trgMask |=AliAODForwardMult::kB;
    else if (s.CompareTo("A")     == 0) trgMask |=AliAODForwardMult::kA;
    else if (s.CompareTo("C")     == 0) trgMask |=AliAODForwardMult::kC;
    else if (s.CompareTo("SAT")   == 0) trgMask |=AliAODForwardMult::kSatellite;
    else if (s.CompareTo("E")     == 0) trgMask |=AliAODForwardMult::kE;
    else if (s.CompareTo("NCLUSTER>0") == 0) 
      trgMask |= AliAODForwardMult::kNClusterGt0;
    else 
      AliWarningGeneral("MakeTriggerMask", 
			Form("Unknown trigger %s", s.Data()));
  }
  delete parts;
  return trgMask;
}

//____________________________________________________________________
Bool_t
AliAODForwardMult::CheckEvent(Int_t    triggerMask,
			      Double_t vzMin, Double_t vzMax,
			      UShort_t cMin,  UShort_t cMax, 
			      TH1*     hist) const
{
  // 
  // Check if event meets the passses requirements.   
  //
  // It returns true if @e all of the following is true 
  //
  // - The trigger is within the bit mask passed.
  // - The vertex is within the specified limits. 
  // - The centrality is within the specified limits, or if lower
  //   limit is equal to or larger than the upper limit.
  // 
  // If a histogram is passed in the last parameter, then that
  // histogram is filled with the trigger bits. 
  // 
  // Parameters:
  //    triggerMask  Trigger mask
  //    vzMin        Minimum @f$ v_z@f$ (in centimeters)
  //    vzMax        Maximum @f$ v_z@f$ (in centimeters) 
  //    cMin         Minimum centrality (in percent)
  //    cMax         Maximum centrality (in percent)
  //    hist         Histogram to fill 
  // 
  // Return:
  //    @c true if the event meets the requirements 
  //
  if (cMin < cMax && (cMin > fCentrality || cMax <= fCentrality)) return false;

  if (hist) { 
    Int_t tmp = triggerMask & ~kB;
    hist->AddBinContent(kBinAll);
    if (IsTriggerBits(kB|tmp))          hist->AddBinContent(kBinB);
    if (IsTriggerBits(kA|tmp))          hist->AddBinContent(kBinA);
    if (IsTriggerBits(kC|tmp))          hist->AddBinContent(kBinC);
    if (IsTriggerBits(kE|tmp))          hist->AddBinContent(kBinE);
    if (IsTriggerBits(kB|kInel))        hist->AddBinContent(kBinInel);
    if (IsTriggerBits(kB|kInelGt0))     hist->AddBinContent(kBinInelGt0);
    if (IsTriggerBits(kB|kNSD))         hist->AddBinContent(kBinNSD);
    if (IsTriggerBits(kB|kV0AND))       hist->AddBinContent(kBinV0AND);
    if (IsTriggerBits(kPileUp))         hist->AddBinContent(kBinPileUp);
    if (IsTriggerBits(kMCNSD))          hist->AddBinContent(kBinMCNSD);
    if (IsTriggerBits(kOffline))        hist->AddBinContent(kBinOffline);
    if (IsTriggerBits(kNClusterGt0))    hist->AddBinContent(kBinNClusterGt0);
    if (IsTriggerBits(kSatellite))      hist->AddBinContent(kBinSatellite);
    if (IsTriggerBits(triggerMask) && !IsTriggerBits(kB|tmp))
      Warning("CheckEvent", "event: 0x%x, mask: 0x%x, tmp: 0x%x, tmp|b: 0x%x",
	     fTriggers, triggerMask, tmp, tmp|kB);
  }
  // Check if we have an event of interest. 
  Int_t mask = triggerMask; //|kB
  if (!IsTriggerBits(mask)) return false;
  
  // Check for pileup
  if (IsTriggerBits(kPileUp)) return false;
  if (hist) hist->AddBinContent(kWithTrigger);
  
  // Check that we have a valid vertex
  if (vzMin < vzMax && !HasIpZ()) return false;
  if (hist) hist->AddBinContent(kWithVertex);

  // Check that vertex is within cuts 
  if (vzMin < vzMax && !InRange(vzMin, vzMax)) return false;
  if (hist) hist->AddBinContent(kAccepted);
  
  return true;
}

//____________________________________________________________________
void
AliAODForwardMult::Print(Option_t* option) const
{
  // Print this object 
  // 
  // Parameters: 
  //  option   Passed to TH1::Print 
  fHist.Print(option);
  UShort_t sys = GetSystem();
  TString  str = "unknown";
  switch (sys) { 
  case 1:  str = "pp"; break;
  case 2:  str = "PbPb"; break;
  case 3:  str = "pPb" ; break;
  }
  std::cout << "Ipz:         " << fIpZ << "cm " << (HasIpZ() ? "" : "in") 
	    << "valid\n"
	    << "Triggers:    " << GetTriggerString(fTriggers)  << "\n"
	    << "sNN:         " << GetSNN() << "GeV\n" 
	    << "System:      " << str << "\n"
	    << "Centrality:  " << fCentrality << "%" 
	    << std::endl;
}

//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
f49fc45d	1	//
	2	// Class that contains the forward multiplicity data per event
	3	//
	4	// This class contains a histogram of
	5	// @f[
	6	// \frac{d^2N_{ch}}{d\eta d\phi}\quad,
	7	// @f]
	8	// as well as a trigger mask for each analysed event.
	9	//
	10	// The eta acceptance of the event is stored in the underflow bins of
	11	// the histogram. So to build the final histogram, one needs to
	12	// correct for this acceptance (properly weighted by the events), and
	13	// the vertex efficiency. This simply boils down to defining a 2D
	14	// histogram and summing the event histograms in that histogram. One
	15	// should of course also do proper book-keeping of the accepted event.
	16	//
7e4038b5	17	#include "AliAODForwardMult.h"
	18	#include <TBrowser.h>
	19	#include <iostream>
	20	#include <TMath.h>
	21	#include <TObjString.h>
9453b19e	22	#include <TObjArray.h>
9453b19e	23	#include "AliLog.h"
7e4038b5	24	ClassImp(AliAODForwardMult)
ffca499d	25	#ifdef DOXY_INPUT
7e4038b5	26	; // For Emacs
	27	#endif
	28
	29	//____________________________________________________________________
	30	const Float_t AliAODForwardMult::fgkInvalidIpZ = 1e6;
	31
	32	//____________________________________________________________________
	33	AliAODForwardMult::AliAODForwardMult()
f49fc45d	34	: fIsMC(false),
f49fc45d	35	fHist(),
7e4038b5	36	fTriggers(0),
e58000b7	37	fIpZ(fgkInvalidIpZ),
5bb5d1f6	38	fCentrality(-1),
5bb5d1f6	39	fNClusters(0)
f49fc45d	40	{
	41	//
	42	// Constructor
	43	//
	44	}
7e4038b5	45
7e4038b5	46	//____________________________________________________________________
f49fc45d	47	AliAODForwardMult::AliAODForwardMult(Bool_t isMC)
	48	: fIsMC(isMC),
	49	fHist("forwardMult", "d^{2}N_{ch}/d#etad#varphi in the forward regions",
7e4038b5	50	200, -4, 6, 20, 0, 2*TMath::Pi()),
7e4038b5	51	fTriggers(0),
e58000b7	52	fIpZ(fgkInvalidIpZ),
5bb5d1f6	53	fCentrality(-1),
5bb5d1f6	54	fNClusters(0)
7e4038b5	55	{
f49fc45d	56	//
	57	// Constructor
	58	//
	59	// Parameters:
	60	// isMC If set to true this is for MC data (effects branch name)
	61	//
7e4038b5	62	fHist.SetXTitle("#eta");
	63	fHist.SetYTitle("#varphi [radians]");
	64	fHist.SetZTitle("#frac{d^{2}N_{ch}}{d#etad#varphi}");
f49fc45d	65	fHist.SetDirectory(0);
7e4038b5	66	fHist.Sumw2();
	67	}
	68
	69	//____________________________________________________________________
	70	void
	71	AliAODForwardMult::Init(const TAxis& etaAxis)
	72	{
f49fc45d	73	// Initialize the histogram with an eta axis
	74	//
	75	// Parameters:
	76	// etaAxis Eta axis to use
	77	//
7e4038b5	78	fHist.SetBins(etaAxis.GetNbins(), etaAxis.GetXmin(), etaAxis.GetXmax(),
	79	20, 0, 2*TMath::Pi());
	80	}
	81
	82	//____________________________________________________________________
	83	void
	84	AliAODForwardMult::Clear(Option_t* option)
	85	{
f49fc45d	86	// Clear (or reset) internal values
	87	//
	88	// Parameters:
	89	// option Passed to TH1::Reset
	90	//
7e4038b5	91	fHist.Reset(option);
5bb5d1f6	92	fTriggers = 0;
	93	fIpZ = fgkInvalidIpZ;
	94	fNClusters = 0;
7e4038b5	95	}
b2e7f2d6	96	//____________________________________________________________________
	97	void
	98	AliAODForwardMult::SetSNN(UShort_t snn)
	99	{
	100	// set the center of mass energy per nucleon pair (GeV).
	101	// This is stored in bin (0,0) of the histogram
	102	//
	103	// Parameters:
	104	// sNN Center of mass energy per nuclean
	105	fHist.SetBinContent(0,0,snn);
	106	}
	107	//____________________________________________________________________
	108	void
	109	AliAODForwardMult::SetSystem(UShort_t sys)
	110	{
	111	// set the center of mass energy per nucleon pair (GeV).
	112	// This is stored in bin (N+1,0) of the histogram
	113	//
	114	// Parameters:
	115	// sys Collision system number
	116	fHist.SetBinContent(fHist.GetNbinsX()+1,0,sys);
	117	}
	118
7e4038b5	119	//____________________________________________________________________
	120	Bool_t
	121	AliAODForwardMult::HasIpZ() const
	122	{
f49fc45d	123	// Check if we have valid z coordinate of the interaction point
	124	//
	125	// Return:
	126	// true if the z coordinate of the interaction point is valid
	127	//
7e4038b5	128	return TMath::Abs(fIpZ - fgkInvalidIpZ) > 1;
	129	}
	130
b2e7f2d6	131	//____________________________________________________________________
	132	UShort_t
	133	AliAODForwardMult::GetSNN() const
	134	{
	135	// set the center of mass energy per nucleon pair (GeV).
	136	// This is stored in bin (0,0) of the histogram
	137	//
	138	// Parameters:
	139	// sNN Center of mass energy per nuclean
8e2bb72a	140	return UShort_t(fHist.GetBinContent(0,0));
b2e7f2d6	141	}
	142
	143	//____________________________________________________________________
	144	UShort_t
	145	AliAODForwardMult::GetSystem() const
	146	{
	147	// set the center of mass energy per nucleon pair (GeV).
	148	// This is stored in bin (N+1,0) of the histogram
	149	//
	150	// Parameters:
	151	// sNN Center of mass energy per nuclean
8e2bb72a	152	return UShort_t(fHist.GetBinContent(fHist.GetNbinsX()+1,0));
b2e7f2d6	153	}
b2e7f2d6	154
7e4038b5	155	//____________________________________________________________________
	156	void
	157	AliAODForwardMult::Browse(TBrowser* b)
	158	{
f49fc45d	159	// Browse this object
	160	//
	161	// Parameters:
	162	// b Browser to use
7e4038b5	163	static TObjString ipz;
7e4038b5	164	static TObjString trg;
e58000b7	165	static TObjString cnt;
5bb5d1f6	166	static TObjString ncl;
7e4038b5	167	ipz = Form("ip_z=%fcm", fIpZ);
7e4038b5	168	trg = GetTriggerString(fTriggers);
e58000b7	169	cnt = Form("%+6.1f%%", fCentrality);
5bb5d1f6	170	ncl = Form("%d clusters", fNClusters);
7e4038b5	171	b->Add(&fHist);
	172	b->Add(&ipz);
	173	b->Add(&trg);
e58000b7	174	b->Add(&cnt);
5bb5d1f6	175	b->Add(&ncl);
7e4038b5	176	}
7e4038b5	177
321cf27d	178	namespace {
	179	void AppendAnd(TString& trg, const TString& what)
	180	{
	181	if (!trg.IsNull()) trg.Append(" & ");
	182	trg.Append(what);
	183	}
	184	}
7e4038b5	185	//____________________________________________________________________
	186	const Char_t*
	187	AliAODForwardMult::GetTriggerString(UInt_t mask)
	188	{
f49fc45d	189	// Get a string that describes the triggers
	190	//
	191	// Parameters:
	192	// mask Bit pattern of triggers
	193	// Return:
	194	// Character string representation of mask
7e4038b5	195	static TString trg;
7e4038b5	196	trg = "";
321cf27d	197	if ((mask & kInel) != 0x0) AppendAnd(trg, "INEL");
	198	if ((mask & kInelGt0) != 0x0) AppendAnd(trg, "INEL>0");
	199	if ((mask & kNSD) != 0x0) AppendAnd(trg, "NSD");
	200	if ((mask & kV0AND) != 0x0) AppendAnd(trg, "V0AND");
	201	if ((mask & kA) != 0x0) AppendAnd(trg, "A");
	202	if ((mask & kB) != 0x0) AppendAnd(trg, "B");
	203	if ((mask & kC) != 0x0) AppendAnd(trg, "C");
	204	if ((mask & kE) != 0x0) AppendAnd(trg, "E");
	205	if ((mask & kMCNSD) != 0x0) AppendAnd(trg, "MCNSD");
	206	if ((mask & kNClusterGt0) != 0x0) AppendAnd(trg, "NCluster>0");
8449e3e0	207	if ((mask & kSatellite) != 0x0) AppendAnd(trg, "Satellite");
7e4038b5	208	return trg.Data();
	209	}
	210
e938e22b	211	//____________________________________________________________________
e938e22b	212	TH1I*
321cf27d	213	AliAODForwardMult::MakeTriggerHistogram(const char* name, Int_t mask)
e938e22b	214	{
ffca499d	215	//
	216	// Make a histogram to record triggers in.
	217	//
	218	// The bins defined by the trigger enumeration in this class. One
	219	// can use this enumeration to retrieve the number of triggers for
	220	// each class.
	221	//
	222	// Parameters:
	223	// name Name of the histogram
	224	//
	225	// Return:
	226	// Newly allocated histogram
	227	//
321cf27d	228	TString sel("");
	229	TString andSel("");
	230	if (mask > 0) {
	231	sel = GetTriggerString(mask);
	232	andSel = GetTriggerString(mask & ~kB);
	233	andSel.Prepend(" & ");
	234	}
e938e22b	235	TH1I* ret = new TH1I(name, "Triggers", kAccepted+1, -.5, kAccepted+.5);
	236	ret->SetYTitle("Events");
	237	ret->SetFillColor(kRed+1);
	238	ret->SetFillStyle(3001);
	239	ret->GetXaxis()->SetBinLabel(kBinAll, "All events");
cd548b09	240	ret->GetXaxis()->SetBinLabel(kBinB, Form("B (Coll.)%s",
cd548b09	241	andSel.Data()));
321cf27d	242	ret->GetXaxis()->SetBinLabel(kBinA, Form("A%s", andSel.Data()));
	243	ret->GetXaxis()->SetBinLabel(kBinC, Form("C%s", andSel.Data()));
	244	ret->GetXaxis()->SetBinLabel(kBinE, Form("E%s", andSel.Data()));
cd548b09	245	ret->GetXaxis()->SetBinLabel(kBinInel, "Coll. & INEL");
	246	ret->GetXaxis()->SetBinLabel(kBinInelGt0, "Coll. & INEL>0");
	247	ret->GetXaxis()->SetBinLabel(kBinNSD, "Coll. & NSD");
	248	ret->GetXaxis()->SetBinLabel(kBinV0AND, "Coll. & V0AND");
e938e22b	249	ret->GetXaxis()->SetBinLabel(kBinMCNSD, "NSD (MC truth)");
8449e3e0	250	ret->GetXaxis()->SetBinLabel(kBinSatellite, "Satellite");
e938e22b	251	ret->GetXaxis()->SetBinLabel(kBinPileUp, "w/Pileup");
0be6c8cd	252	ret->GetXaxis()->SetBinLabel(kBinOffline, "w/Offline");
5bb5d1f6	253	ret->GetXaxis()->SetBinLabel(kBinNClusterGt0, "w/N_{cluster}>1");
e938e22b	254	ret->GetXaxis()->SetBinLabel(kWithVertex, "w/Vertex");
321cf27d	255	ret->GetXaxis()->SetBinLabel(kWithTrigger, Form("w/Selected trigger (%s)",
321cf27d	256	sel.Data()));
e938e22b	257	ret->GetXaxis()->SetBinLabel(kAccepted, "Accepted by cut");
	258	ret->GetXaxis()->SetNdivisions(kAccepted, false);
	259	ret->SetStats(0);
	260
	261	return ret;
	262	}
9453b19e	263	//____________________________________________________________________
	264	UInt_t
	265	AliAODForwardMult::MakeTriggerMask(const char* what)
	266	{
	267	UShort_t trgMask = 0;
	268	TString trgs(what);
	269	trgs.ToUpper();
321cf27d	270	TObjArray* parts = trgs.Tokenize("&");
9453b19e	271	TObjString* trg;
321cf27d	272	TIter next(parts);
9453b19e	273	while ((trg = static_cast<TObjString*>(next()))) {
9453b19e	274	TString s(trg->GetString());
321cf27d	275	s.Strip(TString::kBoth, ' ');
321cf27d	276	s.ToUpper();
9453b19e	277	if (s.IsNull()) continue;
8449e3e0	278	if (s.CompareTo("INEL") == 0) trgMask \|=AliAODForwardMult::kInel;
	279	else if (s.CompareTo("INEL>0")== 0) trgMask \|=AliAODForwardMult::kInelGt0;
	280	else if (s.CompareTo("NSD") == 0) trgMask \|=AliAODForwardMult::kNSD;
	281	else if (s.CompareTo("V0AND") == 0) trgMask \|=AliAODForwardMult::kV0AND;
	282	else if (s.CompareTo("MCNSD") == 0) trgMask \|=AliAODForwardMult::kMCNSD;
	283	else if (s.CompareTo("B") == 0) trgMask \|=AliAODForwardMult::kB;
	284	else if (s.CompareTo("A") == 0) trgMask \|=AliAODForwardMult::kA;
	285	else if (s.CompareTo("C") == 0) trgMask \|=AliAODForwardMult::kC;
	286	else if (s.CompareTo("SAT") == 0) trgMask \|=AliAODForwardMult::kSatellite;
	287	else if (s.CompareTo("E") == 0) trgMask \|=AliAODForwardMult::kE;
1751861f	288	else if (s.CompareTo("NCLUSTER>0") == 0)
5bb5d1f6	289	trgMask \|= AliAODForwardMult::kNClusterGt0;
9453b19e	290	else
	291	AliWarningGeneral("MakeTriggerMask",
	292	Form("Unknown trigger %s", s.Data()));
	293	}
09d5920f	294	delete parts;
9453b19e	295	return trgMask;
9453b19e	296	}
e938e22b	297
	298	//____________________________________________________________________
	299	Bool_t
	300	AliAODForwardMult::CheckEvent(Int_t triggerMask,
	301	Double_t vzMin, Double_t vzMax,
	302	UShort_t cMin, UShort_t cMax,
	303	TH1* hist) const
	304	{
ffca499d	305	//
	306	// Check if event meets the passses requirements.
	307	//
	308	// It returns true if @e all of the following is true
	309	//
	310	// - The trigger is within the bit mask passed.
	311	// - The vertex is within the specified limits.
	312	// - The centrality is within the specified limits, or if lower
	313	// limit is equal to or larger than the upper limit.
	314	//
	315	// If a histogram is passed in the last parameter, then that
	316	// histogram is filled with the trigger bits.
	317	//
	318	// Parameters:
	319	// triggerMask Trigger mask
	320	// vzMin Minimum @f$ v_z@f$ (in centimeters)
	321	// vzMax Maximum @f$ v_z@f$ (in centimeters)
	322	// cMin Minimum centrality (in percent)
	323	// cMax Maximum centrality (in percent)
	324	// hist Histogram to fill
	325	//
	326	// Return:
	327	// @c true if the event meets the requirements
	328	//
e938e22b	329	if (cMin < cMax && (cMin > fCentrality \|\| cMax <= fCentrality)) return false;
	330
	331	if (hist) {
321cf27d	332	Int_t tmp = triggerMask & ~kB;
e938e22b	333	hist->AddBinContent(kBinAll);
321cf27d	334	if (IsTriggerBits(kB\|tmp)) hist->AddBinContent(kBinB);
	335	if (IsTriggerBits(kA\|tmp)) hist->AddBinContent(kBinA);
	336	if (IsTriggerBits(kC\|tmp)) hist->AddBinContent(kBinC);
	337	if (IsTriggerBits(kE\|tmp)) hist->AddBinContent(kBinE);
0be6c8cd	338	if (IsTriggerBits(kB\|kInel)) hist->AddBinContent(kBinInel);
	339	if (IsTriggerBits(kB\|kInelGt0)) hist->AddBinContent(kBinInelGt0);
	340	if (IsTriggerBits(kB\|kNSD)) hist->AddBinContent(kBinNSD);
e6463868	341	if (IsTriggerBits(kB\|kV0AND)) hist->AddBinContent(kBinV0AND);
0be6c8cd	342	if (IsTriggerBits(kPileUp)) hist->AddBinContent(kBinPileUp);
	343	if (IsTriggerBits(kMCNSD)) hist->AddBinContent(kBinMCNSD);
	344	if (IsTriggerBits(kOffline)) hist->AddBinContent(kBinOffline);
5bb5d1f6	345	if (IsTriggerBits(kNClusterGt0)) hist->AddBinContent(kBinNClusterGt0);
8449e3e0	346	if (IsTriggerBits(kSatellite)) hist->AddBinContent(kBinSatellite);
321cf27d	347	if (IsTriggerBits(triggerMask) && !IsTriggerBits(kB\|tmp))
	348	Warning("CheckEvent", "event: 0x%x, mask: 0x%x, tmp: 0x%x, tmp\|b: 0x%x",
	349	fTriggers, triggerMask, tmp, tmp\|kB);
e938e22b	350	}
e938e22b	351	// Check if we have an event of interest.
f7cfc454	352	Int_t mask = triggerMask; //\|kB
f7cfc454	353	if (!IsTriggerBits(mask)) return false;
e938e22b	354
	355	// Check for pileup
	356	if (IsTriggerBits(kPileUp)) return false;
	357	if (hist) hist->AddBinContent(kWithTrigger);
	358
	359	// Check that we have a valid vertex
b6b35c77	360	if (vzMin < vzMax && !HasIpZ()) return false;
e938e22b	361	if (hist) hist->AddBinContent(kWithVertex);
	362
	363	// Check that vertex is within cuts
b6b35c77	364	if (vzMin < vzMax && !InRange(vzMin, vzMax)) return false;
e938e22b	365	if (hist) hist->AddBinContent(kAccepted);
	366
	367	return true;
	368	}
	369
7e4038b5	370	//____________________________________________________________________
	371	void
	372	AliAODForwardMult::Print(Option_t* option) const
	373	{
f49fc45d	374	// Print this object
	375	//
	376	// Parameters:
	377	// option Passed to TH1::Print
7e4038b5	378	fHist.Print(option);
8e2bb72a	379	UShort_t sys = GetSystem();
	380	TString str = "unknown";
	381	switch (sys) {
	382	case 1: str = "pp"; break;
	383	case 2: str = "PbPb"; break;
321cf27d	384	case 3: str = "pPb" ; break;
8e2bb72a	385	}
e58000b7	386	std::cout << "Ipz: " << fIpZ << "cm " << (HasIpZ() ? "" : "in")
7e4038b5	387	<< "valid\n"
321cf27d	388	<< "Triggers: " << GetTriggerString(fTriggers) << "\n"
e58000b7	389	<< "sNN: " << GetSNN() << "GeV\n"
321cf27d	390	<< "System: " << str << "\n"
e58000b7	391	<< "Centrality: " << fCentrality << "%"
8e2bb72a	392	<< std::endl;
7e4038b5	393	}
	394
	395	//____________________________________________________________________
	396	//
	397	// EOF
	398	//