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

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