[u/mrichter/AliRoot.git] / PWG2 / 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);
}

//____________________________________________________________________
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) trg.Append("INEL ");
  if ((mask & kInelGt0)     != 0x0) trg.Append("INEL>0 ");
  if ((mask & kNSD)         != 0x0) trg.Append("NSD ");
  if ((mask & kA)           != 0x0) trg.Append("A ");
  if ((mask & kB)           != 0x0) trg.Append("B ");
  if ((mask & kC)           != 0x0) trg.Append("C ");
  if ((mask & kE)           != 0x0) trg.Append("E ");
  if ((mask & kMCNSD)       != 0x0) trg.Append("MCNSD ");
  if ((mask & kNClusterGt0) != 0x0) trg.Append("NCluster>0 ");
  return trg.Data();
}
  
//____________________________________________________________________
TH1I*
AliAODForwardMult::MakeTriggerHistogram(const char* name) 
{
  // 
  // 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 
  //
  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,           "w/B trigger");
  ret->GetXaxis()->SetBinLabel(kBinA,           "w/A trigger");
  ret->GetXaxis()->SetBinLabel(kBinC,           "w/C trigger");
  ret->GetXaxis()->SetBinLabel(kBinE,           "w/E trigger");
  ret->GetXaxis()->SetBinLabel(kBinInel,        "Minimum Bias");
  ret->GetXaxis()->SetBinLabel(kBinInelGt0,     "INEL>0");
  ret->GetXaxis()->SetBinLabel(kBinNSD,         "NSD");
  ret->GetXaxis()->SetBinLabel(kBinMCNSD,       "NSD (MC truth)");
  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,    "w/Selected trigger");
  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();
  TObjString* trg;
  TIter       next(trgs.Tokenize(" ,|"));
  while ((trg = static_cast<TObjString*>(next()))) { 
    TString s(trg->GetString());
    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("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("E")     == 0) trgMask |= AliAODForwardMult::kE;
    else if (s.CompareTo("NCLUSTER>0") == 0) 
      trgMask |= AliAODForwardMult::kNClusterGt0;
    else 
      AliWarningGeneral("MakeTriggerMask", 
			Form("Unknown trigger %s", s.Data()));
  }
  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) { 
    hist->AddBinContent(kBinAll);
    if (IsTriggerBits(kB|triggerMask))  hist->AddBinContent(kBinB);
    if (IsTriggerBits(kA|triggerMask))  hist->AddBinContent(kBinA);
    if (IsTriggerBits(kC|triggerMask))  hist->AddBinContent(kBinC);
    if (IsTriggerBits(kE|triggerMask))  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(kPileUp))         hist->AddBinContent(kBinPileUp);
    if (IsTriggerBits(kMCNSD))          hist->AddBinContent(kBinMCNSD);
    if (IsTriggerBits(kOffline))        hist->AddBinContent(kBinOffline);
    if (IsTriggerBits(kNClusterGt0))    hist->AddBinContent(kBinNClusterGt0);
  }
  // Check if we have an event of interest. 
  if (!IsTriggerBits(triggerMask|kB)) 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;
  }
  std::cout << "Ipz:         " << fIpZ << "cm " << (HasIpZ() ? "" : "in") 
	    << "valid\n"
	    << "Triggers:    " << GetTriggerString(fTriggers) 
	    << "sNN:         " << GetSNN() << "GeV\n" 
	    << "System:      " << str 
	    << "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	}
	177
	178	//____________________________________________________________________
	179	const Char_t*
	180	AliAODForwardMult::GetTriggerString(UInt_t mask)
	181	{
f49fc45d	182	// Get a string that describes the triggers
	183	//
	184	// Parameters:
	185	// mask Bit pattern of triggers
	186	// Return:
	187	// Character string representation of mask
7e4038b5	188	static TString trg;
7e4038b5	189	trg = "";
e58000b7	190	if ((mask & kInel) != 0x0) trg.Append("INEL ");
	191	if ((mask & kInelGt0) != 0x0) trg.Append("INEL>0 ");
	192	if ((mask & kNSD) != 0x0) trg.Append("NSD ");
	193	if ((mask & kA) != 0x0) trg.Append("A ");
	194	if ((mask & kB) != 0x0) trg.Append("B ");
	195	if ((mask & kC) != 0x0) trg.Append("C ");
	196	if ((mask & kE) != 0x0) trg.Append("E ");
	197	if ((mask & kMCNSD) != 0x0) trg.Append("MCNSD ");
5bb5d1f6	198	if ((mask & kNClusterGt0) != 0x0) trg.Append("NCluster>0 ");
7e4038b5	199	return trg.Data();
	200	}
	201
e938e22b	202	//____________________________________________________________________
	203	TH1I*
	204	AliAODForwardMult::MakeTriggerHistogram(const char* name)
	205	{
ffca499d	206	//
	207	// Make a histogram to record triggers in.
	208	//
	209	// The bins defined by the trigger enumeration in this class. One
	210	// can use this enumeration to retrieve the number of triggers for
	211	// each class.
	212	//
	213	// Parameters:
	214	// name Name of the histogram
	215	//
	216	// Return:
	217	// Newly allocated histogram
	218	//
e938e22b	219	TH1I* ret = new TH1I(name, "Triggers", kAccepted+1, -.5, kAccepted+.5);
	220	ret->SetYTitle("Events");
	221	ret->SetFillColor(kRed+1);
	222	ret->SetFillStyle(3001);
	223	ret->GetXaxis()->SetBinLabel(kBinAll, "All events");
	224	ret->GetXaxis()->SetBinLabel(kBinB, "w/B trigger");
	225	ret->GetXaxis()->SetBinLabel(kBinA, "w/A trigger");
	226	ret->GetXaxis()->SetBinLabel(kBinC, "w/C trigger");
	227	ret->GetXaxis()->SetBinLabel(kBinE, "w/E trigger");
	228	ret->GetXaxis()->SetBinLabel(kBinInel, "Minimum Bias");
	229	ret->GetXaxis()->SetBinLabel(kBinInelGt0, "INEL>0");
	230	ret->GetXaxis()->SetBinLabel(kBinNSD, "NSD");
	231	ret->GetXaxis()->SetBinLabel(kBinMCNSD, "NSD (MC truth)");
	232	ret->GetXaxis()->SetBinLabel(kBinPileUp, "w/Pileup");
0be6c8cd	233	ret->GetXaxis()->SetBinLabel(kBinOffline, "w/Offline");
5bb5d1f6	234	ret->GetXaxis()->SetBinLabel(kBinNClusterGt0, "w/N_{cluster}>1");
e938e22b	235	ret->GetXaxis()->SetBinLabel(kWithVertex, "w/Vertex");
	236	ret->GetXaxis()->SetBinLabel(kWithTrigger, "w/Selected trigger");
	237	ret->GetXaxis()->SetBinLabel(kAccepted, "Accepted by cut");
	238	ret->GetXaxis()->SetNdivisions(kAccepted, false);
	239	ret->SetStats(0);
	240
	241	return ret;
	242	}
9453b19e	243	//____________________________________________________________________
	244	UInt_t
	245	AliAODForwardMult::MakeTriggerMask(const char* what)
	246	{
	247	UShort_t trgMask = 0;
	248	TString trgs(what);
	249	trgs.ToUpper();
	250	TObjString* trg;
	251	TIter next(trgs.Tokenize(" ,\|"));
	252	while ((trg = static_cast<TObjString*>(next()))) {
	253	TString s(trg->GetString());
	254	if (s.IsNull()) continue;
	255	if (s.CompareTo("INEL") == 0) trgMask \|= AliAODForwardMult::kInel;
	256	else if (s.CompareTo("INEL>0")== 0) trgMask \|= AliAODForwardMult::kInelGt0;
	257	else if (s.CompareTo("NSD") == 0) trgMask \|= AliAODForwardMult::kNSD;
b6b35c77	258	else if (s.CompareTo("B") == 0) trgMask \|= AliAODForwardMult::kB;
	259	else if (s.CompareTo("A") == 0) trgMask \|= AliAODForwardMult::kA;
	260	else if (s.CompareTo("C") == 0) trgMask \|= AliAODForwardMult::kC;
	261	else if (s.CompareTo("E") == 0) trgMask \|= AliAODForwardMult::kE;
1751861f	262	else if (s.CompareTo("NCLUSTER>0") == 0)
5bb5d1f6	263	trgMask \|= AliAODForwardMult::kNClusterGt0;
9453b19e	264	else
	265	AliWarningGeneral("MakeTriggerMask",
	266	Form("Unknown trigger %s", s.Data()));
	267	}
	268	return trgMask;
	269	}
e938e22b	270
	271	//____________________________________________________________________
	272	Bool_t
	273	AliAODForwardMult::CheckEvent(Int_t triggerMask,
	274	Double_t vzMin, Double_t vzMax,
	275	UShort_t cMin, UShort_t cMax,
	276	TH1* hist) const
	277	{
ffca499d	278	//
	279	// Check if event meets the passses requirements.
	280	//
	281	// It returns true if @e all of the following is true
	282	//
	283	// - The trigger is within the bit mask passed.
	284	// - The vertex is within the specified limits.
	285	// - The centrality is within the specified limits, or if lower
	286	// limit is equal to or larger than the upper limit.
	287	//
	288	// If a histogram is passed in the last parameter, then that
	289	// histogram is filled with the trigger bits.
	290	//
	291	// Parameters:
	292	// triggerMask Trigger mask
	293	// vzMin Minimum @f$ v_z@f$ (in centimeters)
	294	// vzMax Maximum @f$ v_z@f$ (in centimeters)
	295	// cMin Minimum centrality (in percent)
	296	// cMax Maximum centrality (in percent)
	297	// hist Histogram to fill
	298	//
	299	// Return:
	300	// @c true if the event meets the requirements
	301	//
e938e22b	302	if (cMin < cMax && (cMin > fCentrality \|\| cMax <= fCentrality)) return false;
	303
	304	if (hist) {
	305	hist->AddBinContent(kBinAll);
0be6c8cd	306	if (IsTriggerBits(kB\|triggerMask)) hist->AddBinContent(kBinB);
	307	if (IsTriggerBits(kA\|triggerMask)) hist->AddBinContent(kBinA);
	308	if (IsTriggerBits(kC\|triggerMask)) hist->AddBinContent(kBinC);
	309	if (IsTriggerBits(kE\|triggerMask)) hist->AddBinContent(kBinE);
	310	if (IsTriggerBits(kB\|kInel)) hist->AddBinContent(kBinInel);
	311	if (IsTriggerBits(kB\|kInelGt0)) hist->AddBinContent(kBinInelGt0);
	312	if (IsTriggerBits(kB\|kNSD)) hist->AddBinContent(kBinNSD);
	313	if (IsTriggerBits(kPileUp)) hist->AddBinContent(kBinPileUp);
	314	if (IsTriggerBits(kMCNSD)) hist->AddBinContent(kBinMCNSD);
	315	if (IsTriggerBits(kOffline)) hist->AddBinContent(kBinOffline);
5bb5d1f6	316	if (IsTriggerBits(kNClusterGt0)) hist->AddBinContent(kBinNClusterGt0);
e938e22b	317	}
e938e22b	318	// Check if we have an event of interest.
0be6c8cd	319	if (!IsTriggerBits(triggerMask\|kB)) return false;
e938e22b	320
	321	// Check for pileup
	322	if (IsTriggerBits(kPileUp)) return false;
	323	if (hist) hist->AddBinContent(kWithTrigger);
	324
	325	// Check that we have a valid vertex
b6b35c77	326	if (vzMin < vzMax && !HasIpZ()) return false;
e938e22b	327	if (hist) hist->AddBinContent(kWithVertex);
	328
	329	// Check that vertex is within cuts
b6b35c77	330	if (vzMin < vzMax && !InRange(vzMin, vzMax)) return false;
e938e22b	331	if (hist) hist->AddBinContent(kAccepted);
	332
	333	return true;
	334	}
	335
7e4038b5	336	//____________________________________________________________________
	337	void
	338	AliAODForwardMult::Print(Option_t* option) const
	339	{
f49fc45d	340	// Print this object
	341	//
	342	// Parameters:
	343	// option Passed to TH1::Print
7e4038b5	344	fHist.Print(option);
8e2bb72a	345	UShort_t sys = GetSystem();
	346	TString str = "unknown";
	347	switch (sys) {
	348	case 1: str = "pp"; break;
	349	case 2: str = "PbPb"; break;
	350	}
e58000b7	351	std::cout << "Ipz: " << fIpZ << "cm " << (HasIpZ() ? "" : "in")
7e4038b5	352	<< "valid\n"
e58000b7	353	<< "Triggers: " << GetTriggerString(fTriggers)
	354	<< "sNN: " << GetSNN() << "GeV\n"
	355	<< "System: " << str
	356	<< "Centrality: " << fCentrality << "%"
8e2bb72a	357	<< std::endl;
7e4038b5	358	}
	359
	360	//____________________________________________________________________
	361	//
	362	// EOF
	363	//