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

#include "AliFMDMultCuts.h"
#include "AliForwardCorrectionManager.h"
#include "AliFMDCorrELossFit.h"
#include "AliForwardUtil.h"
#include <AliLog.h>
#include <iostream>
#include <TROOT.h>
#include <TParameter.h>
#include <TH2.h>
namespace { 
  Int_t fDebug = 1;
}
ClassImp(AliFMDMultCuts)
#if 0
; // This is for Emacs
#endif

//____________________________________________________________________
AliFMDMultCuts::AliFMDMultCuts()
  : TObject(),
    fMethod(kFixed)
{
  Reset();
}
//____________________________________________________________________
AliFMDMultCuts::AliFMDMultCuts(EMethod method, 
			       Double_t cut1,  
			       Double_t cut2,
			       Double_t cut3,
			       Double_t cut4,
			       Double_t cut5)
  : TObject(),
    fMethod(method)
{
  Set(method, cut1, cut2, cut3, cut4, cut5);
}

//____________________________________________________________________
AliFMDMultCuts::AliFMDMultCuts(const AliFMDMultCuts& o)
  : TObject(o),
    fMethod(o.fMethod)
{
  for (Int_t i = 0; i < 5; i++) fCuts[i] = o.fCuts[i];
}
//____________________________________________________________________
AliFMDMultCuts&
AliFMDMultCuts::operator=(const AliFMDMultCuts& o)
{
  if (&o == this) return *this; 
  fMethod  = o.fMethod;
  for (Int_t i = 0; i < 5; i++) fCuts[i] = o.fCuts[i];
  return *this;
}
//____________________________________________________________________
void
AliFMDMultCuts::Reset()
{
  fMethod = kFixed;
  for (Int_t i = 0; i < 5; i++) fCuts[i] = -1;
}
//____________________________________________________________________
void
AliFMDMultCuts::Set(EMethod method, 
		    Double_t fmd1i, 
		    Double_t fmd2i, 
		    Double_t fmd2o, 
		    Double_t fmd3i, 
		    Double_t fmd3o)
{
  // First, reset
  Reset();
  fMethod      = method; 
  Double_t oFac = 1;
  if      (fMethod == kFixed)       oFac = 1.2;
  else if (fMethod == kMPVFraction) oFac = 1.1;
  fCuts[0] = fmd1i;
  fCuts[1] = fmd2i >= 0 ? fmd2i : fmd1i;
  fCuts[2] = fmd2o >= 0 ? fmd2o : fmd1i * oFac;
  fCuts[3] = fmd3i >= 0 ? fmd3i : fmd1i;
  fCuts[4] = fmd3o >= 0 ? fmd3o : fmd1i * oFac;
}
//____________________________________________________________________
void
AliFMDMultCuts::DepSet(const char* what,
		       EMethod method, 
		       Double_t fmd1i, 
		       Double_t fmd2i, 
		       Double_t fmd2o, 
		       Double_t fmd3i, 
		       Double_t fmd3o)
{
  Warning(what, "*** DEPRECATED - use AliFMDMultCuts::Set instead ***");
  Set(method, fmd1i, fmd2i, fmd2o, fmd3i, fmd3o);
}
  
//____________________________________________________________________
void
AliFMDMultCuts::SetIncludeSigma(Bool_t in) 
{
  Warning("SetIncludeSigma",  
	  "*** DEPRECATED - use AliFMDMultCuts::Set instead ***");
  if (in) { 
    if (fMethod == kLandauWidth) fMethod = kLandauSigmaWidth;
  }
  else {
    if (fMethod == kLandauSigmaWidth) fMethod = kLandauWidth;
  }
}

//____________________________________________________________________
Double_t
AliFMDMultCuts::GetCutParam(UShort_t d, Char_t r) const
{
  // Int_t    idx = (d == 1 ? 0 : 2*(d - 2) + 1 + ((r=='I' || r=='i') ? 0 : 1));
  Int_t idx = -1;
  switch (d) { 
  case 1: idx = 0; break;
  case 2: idx = 1 + ((r == 'I' || r == 'i') ? 0 : 1); break;
  case 3: idx = 3 + ((r == 'I' || r == 'i') ? 0 : 1); break;
  }
  if (idx < 0) return -kBad;
  return fCuts[idx];
}
			    
//____________________________________________________________________
Double_t
AliFMDMultCuts::GetMultCut(UShort_t d, Char_t r, Int_t ieta, 
			   Bool_t errors) const
{
  // 
  // Get the multiplicity cut.  If the user has set fMultCut (via
  // SetMultCut) then that value is used.  If not, then the lower
  // value of the fit range for the enery loss fits is returned.
  // 
  // Return:
  //    Lower cut on multiplicity
  //
  DGUARD(fDebug, 5, "Get mult cut for FMD%d%c (method %d) @ etabin=%d", 
	 d, r, fMethod, ieta);
  Double_t param = GetCutParam(d, r);
  if (param < 0) {
    Warning("GetMultCut", "Got bad cut parameter for FMD%d%c ieta=%d",
	    d, r, ieta);
    return -kBad;
  }

  // If we're using a fixed cut, just return
  if (fMethod == kFixed) {
    DMSG(fDebug, 5, "-> %8.4f", param);
    return param;
  }

  // Bad value 
  Double_t rcut = -kBad;

  // Get the energy loss fits 
  AliForwardCorrectionManager&  fcm = 
    AliForwardCorrectionManager::Instance();
  const AliFMDCorrELossFit* fits = fcm.GetELossFit();
  if (fits) {
    switch (fMethod) { 
    case kMPVFraction:
      // Return fMPVFraction * mpv 
      rcut = fits->GetLowerBound(d, r, ieta, param); break;
    case kLandauWidth:
      // Return MPV - fNXi * xi
      rcut = fits->GetLowerBound(d, r, ieta, param, errors,false);
      break;
    case kLandauSigmaWidth:
      // Return MPV - fNXi * xi
      rcut = fits->GetLowerBound(d, r, ieta, param, errors,true);
      break;
    case kProbability:
      // Return probability cut 
      rcut = fits->GetLowerBound(d, r, ieta, param, true); break;
    default:
      // Return lower fit boundary
      rcut = fits->GetLowCut(); break;
    }
  }
  else 
    Warning("GetMultCut", "No energy loss fits obtained from manager");

  DMSG(fDebug, 5, "-> %8.4f", rcut);
    
  return rcut;
}
    
//____________________________________________________________________
Double_t
AliFMDMultCuts::GetMultCut(UShort_t d, Char_t r, Double_t eta,
			   Bool_t errors) const
{
  // 
  // Get the multiplicity cut.  If the user has set fMultCut (via
  // SetMultCut) then that value is used.  If not, then the lower
  // value of the fit range for the enery loss fits is returned.
  // 
  // Return:
  //    Lower cut on multiplicity
  //
  DGUARD(fDebug, 5, "Get mult cut for FMD%d%c @ eta=%8.4f", 
	 d, r, eta);
  AliForwardCorrectionManager&  fcm  = AliForwardCorrectionManager::Instance();
  const AliFMDCorrELossFit*     fits = fcm.GetELossFit();
  Int_t                         iEta = fits ? fits->FindEtaBin(eta) : 1;
  DMSG(fDebug, 5, "bin=%4d", iEta);
  return GetMultCut(d, r, iEta, errors);
}
//____________________________________________________________________
const char*
AliFMDMultCuts::GetMethodString(Bool_t latex) const
{
  return Method2String(fMethod, latex);
}

//____________________________________________________________________
const char*
AliFMDMultCuts::Method2String(EMethod method, Bool_t latex)
{
  switch (method) {
  case kFixed:            
    return latex ? "c=X" : "fixed value";
  case kMPVFraction:      
    return latex ? "c=X#times#Delta_{p}":"fraction of MPV";
  case kFitRange:         
    return latex ? "range" : "c: lower fit bound";
  case kLandauWidth:      
    return latex ? "c=#Delta_{p}-X#times#xi" : "landau width";
  case kLandauSigmaWidth: 
    return latex ? "c=#Delta_{p}-X#times(#xi+#sigma)" : "landau+sigma width";
  case kProbability:      
    return latex ? "c:P(#Delta<c)<X" : "probability";
  }
  return latex ? "c:?" : "unknown";
} 
//____________________________________________________________________
AliFMDMultCuts::EMethod
AliFMDMultCuts::String2Method(const char* str)
{
  TString m(str);
  if (m.EqualTo("fixed value")     || m.Contains("fix")) 
    return kFixed;
  else if (m.EqualTo("fraction of mpv") || m.Contains("mpv")) 
    return kMPVFraction;
  else if (m.EqualTo("fit range")       || m.Contains("fit")) 
    return kFitRange;
  else if (m.EqualTo("landau width")    || m.Contains("xi") || 
	   m.Contains("width")) return kLandauWidth;
  else if (m.EqualTo("landau+sigma width") || m.Contains("sig")) 
    return kLandauSigmaWidth;
  else if (m.EqualTo("probability")        || m.Contains("prob")) 
    return kProbability;
  return kFixed;
 } 
  
//____________________________________________________________________
void
AliFMDMultCuts::FillHistogram(TH2* h) const
{
  DGUARD(fDebug, 5, "Fill Histogram %s with cuts", h->GetName());
  // AliInfoF("Caching multiplicity cuts (%s)", h->GetName());
  TAxis* yAxis = h->GetYaxis(); 
  for (Int_t iy = 1; iy <= yAxis->GetNbins(); iy++) { 
    TString lab(yAxis->GetBinLabel(iy));
    lab.Remove(0,3);
    UShort_t det = lab.Atoi();
    Char_t   rng = lab[1];
    // Printf("Filling for FMD%d%c (bin # %d) %s", det, rng, iy, lab.Data());
    DMSG(fDebug, 5, "FMD%d%c", det, rng);
    // AliInfoF("FMD%d%c", det, rng);
    for (Int_t ix = 1; ix <= h->GetNbinsX(); ix++) {
      Double_t eta = h->GetXaxis()->GetBinCenter(ix);
      Double_t c   = GetMultCut(det, rng, eta,  false);
      DMSG(fDebug, 10, "FMD%s bin=%4d -> eta=%8.4f -> %8.4f", 
	   lab.Data(), ix, eta, c);
      // Double_t c = GetMultCut(det, rng, ix, false);
      if (c > 0) h->SetBinContent(ix, iy, c);
    }
  }
}

//____________________________________________________________________
void
AliFMDMultCuts::Output(TList* l, const char* name) const
{
  TList* ll = l;
  if (name && name[0] != '\0') { 
    ll = new TList;
    ll->SetName(name);
    ll->SetOwner();
    l->Add(ll);
  }
    

  ll->Add(AliForwardUtil::MakeParameter("method", UShort_t(fMethod)));
  ll->Add(AliForwardUtil::MakeParameter("fmd1i", fCuts[0]));
  ll->Add(AliForwardUtil::MakeParameter("fmd2i", fCuts[1]));
  ll->Add(AliForwardUtil::MakeParameter("fmd2o", fCuts[2]));
  ll->Add(AliForwardUtil::MakeParameter("fmd3i", fCuts[3]));
  ll->Add(AliForwardUtil::MakeParameter("fmd3o", fCuts[4]));
}
//____________________________________________________________________
Bool_t
AliFMDMultCuts::Input(TList* l, const char* name)
{
  if (!l) return false;
  TList* ll = l;
  if (name && name[0] != '\0') { 
    ll = static_cast<TList*>(l->FindObject(name));
  }
  if (!ll) return false;
  
  TObject* meth    = ll->FindObject("method");
  TObject* fmd1i   = ll->FindObject("fmd1i");
  TObject* fmd2i   = ll->FindObject("fmd2i");
  TObject* fmd2o   = ll->FindObject("fmd2o");
  TObject* fmd3i   = ll->FindObject("fmd3i");
  TObject* fmd3o   = ll->FindObject("fmd3o");
  
  UShort_t methNum = 0;
  
  AliForwardUtil::GetParameter(meth,  methNum);
  switch (methNum) { 
  case 0: fMethod = kFixed;            break;
  case 1: fMethod = kMPVFraction;      break;
  case 2: fMethod = kFitRange;         break;
  case 3: fMethod = kLandauWidth;      break;
  case 4: fMethod = kLandauSigmaWidth; break;
  case 5: fMethod = kProbability;      break;
  }

  AliForwardUtil::GetParameter(fmd1i, fCuts[0]);
  AliForwardUtil::GetParameter(fmd2i, fCuts[1]);
  AliForwardUtil::GetParameter(fmd2o, fCuts[2]);
  AliForwardUtil::GetParameter(fmd3i, fCuts[3]);
  AliForwardUtil::GetParameter(fmd3o, fCuts[4]);
  
  return true;
}
#define PF(N,V,...)					\
  AliForwardUtil::PrintField(N,V, ## __VA_ARGS__)
#define PFB(N,FLAG)				\
  do {									\
    AliForwardUtil::PrintName(N);					\
    std::cout << std::boolalpha << (FLAG) << std::noboolalpha << std::endl; \
  } while(false)
#define PFV(N,VALUE)					\
  do {							\
    AliForwardUtil::PrintName(N);			\
    std::cout << (VALUE) << std::endl; } while(false)
  
//____________________________________________________________________
void
AliFMDMultCuts::Print(Option_t*) const
{
  gROOT->IncreaseDirLevel();
  PFV("Method used", GetMethodString());
  gROOT->IncreaseDirLevel();
  PFV("FMD1i", GetCutParam(1,'I'));
  PFV("FMD2i", GetCutParam(2,'I'));
  PFV("FMD2o", GetCutParam(2,'O'));
  PFV("FMD3i", GetCutParam(3,'I'));
  PFV("FMD3o", GetCutParam(3,'O'));
  gROOT->DecreaseDirLevel();
  gROOT->DecreaseDirLevel();
}
//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
bfcbb65a	1	#include "AliFMDMultCuts.h"
	2	#include "AliForwardCorrectionManager.h"
	3	#include "AliFMDCorrELossFit.h"
241cca4d	4	#include "AliForwardUtil.h"
7095962e	5	#include <AliLog.h>
bfcbb65a	6	#include <iostream>
	7	#include <TROOT.h>
	8	#include <TParameter.h>
7095962e CHC	9	#include <TH2.h>
	10	namespace {
	11	Int_t fDebug = 1;
	12	}
bfcbb65a	13	ClassImp(AliFMDMultCuts)
	14	#if 0
	15	; // This is for Emacs
	16	#endif
	17
	18	//____________________________________________________________________
	19	AliFMDMultCuts::AliFMDMultCuts()
	20	: TObject(),
7d596e9b	21	fMethod(kFixed)
7095962e CHC	22	{
	23	Reset();
	24	}
	25	//____________________________________________________________________
	26	AliFMDMultCuts::AliFMDMultCuts(EMethod method,
	27	Double_t cut1,
	28	Double_t cut2,
	29	Double_t cut3,
	30	Double_t cut4,
	31	Double_t cut5)
	32	: TObject(),
7d596e9b	33	fMethod(method)
bfcbb65a	34	{
7095962e	35	Set(method, cut1, cut2, cut3, cut4, cut5);
bfcbb65a	36	}
7095962e	37
bfcbb65a	38	//____________________________________________________________________
	39	AliFMDMultCuts::AliFMDMultCuts(const AliFMDMultCuts& o)
	40	: TObject(o),
7d596e9b	41	fMethod(o.fMethod)
bfcbb65a	42	{
7d596e9b	43	for (Int_t i = 0; i < 5; i++) fCuts[i] = o.fCuts[i];
bfcbb65a	44	}
	45	//____________________________________________________________________
	46	AliFMDMultCuts&
	47	AliFMDMultCuts::operator=(const AliFMDMultCuts& o)
	48	{
d015ecfe	49	if (&o == this) return *this;
7d596e9b	50	fMethod = o.fMethod;
7d596e9b	51	for (Int_t i = 0; i < 5; i++) fCuts[i] = o.fCuts[i];
bfcbb65a	52	return *this;
bfcbb65a	53	}
7095962e CHC	54	//____________________________________________________________________
	55	void
	56	AliFMDMultCuts::Reset()
	57	{
7d596e9b	58	fMethod = kFixed;
7d596e9b	59	for (Int_t i = 0; i < 5; i++) fCuts[i] = -1;
7095962e CHC	60	}
	61	//____________________________________________________________________
	62	void
	63	AliFMDMultCuts::Set(EMethod method,
7d596e9b	64	Double_t fmd1i,
	65	Double_t fmd2i,
	66	Double_t fmd2o,
	67	Double_t fmd3i,
	68	Double_t fmd3o)
7095962e CHC	69	{
	70	// First, reset
	71	Reset();
7d596e9b	72	fMethod = method;
	73	Double_t oFac = 1;
	74	if (fMethod == kFixed) oFac = 1.2;
	75	else if (fMethod == kMPVFraction) oFac = 1.1;
	76	fCuts[0] = fmd1i;
	77	fCuts[1] = fmd2i >= 0 ? fmd2i : fmd1i;
	78	fCuts[2] = fmd2o >= 0 ? fmd2o : fmd1i * oFac;
	79	fCuts[3] = fmd3i >= 0 ? fmd3i : fmd1i;
	80	fCuts[4] = fmd3o >= 0 ? fmd3o : fmd1i * oFac;
	81	}
	82	//____________________________________________________________________
	83	void
	84	AliFMDMultCuts::DepSet(const char* what,
	85	EMethod method,
	86	Double_t fmd1i,
	87	Double_t fmd2i,
	88	Double_t fmd2o,
	89	Double_t fmd3i,
	90	Double_t fmd3o)
	91	{
	92	Warning(what, "* DEPRECATED - use AliFMDMultCuts::Set instead *");
	93	Set(method, fmd1i, fmd2i, fmd2o, fmd3i, fmd3o);
	94	}
7095962e	95
7d596e9b	96	//____________________________________________________________________
	97	void
	98	AliFMDMultCuts::SetIncludeSigma(Bool_t in)
	99	{
	100	Warning("SetIncludeSigma",
	101	"* DEPRECATED - use AliFMDMultCuts::Set instead *");
	102	if (in) {
	103	if (fMethod == kLandauWidth) fMethod = kLandauSigmaWidth;
	104	}
	105	else {
	106	if (fMethod == kLandauSigmaWidth) fMethod = kLandauWidth;
7095962e CHC	107	}
7095962e CHC	108	}
bfcbb65a	109
	110	//____________________________________________________________________
	111	Double_t
7d596e9b	112	AliFMDMultCuts::GetCutParam(UShort_t d, Char_t r) const
bfcbb65a	113	{
	114	// Int_t idx = (d == 1 ? 0 : 2*(d - 2) + 1 + ((r=='I' \|\| r=='i') ? 0 : 1));
	115	Int_t idx = -1;
	116	switch (d) {
	117	case 1: idx = 0; break;
b63fc7df	118	case 2: idx = 1 + ((r == 'I' \|\| r == 'i') ? 0 : 1); break;
b63fc7df	119	case 3: idx = 3 + ((r == 'I' \|\| r == 'i') ? 0 : 1); break;
bfcbb65a	120	}
7d596e9b	121	if (idx < 0) return -kBad;
7d596e9b	122	return fCuts[idx];
bfcbb65a	123	}
bfcbb65a	124
	125	//____________________________________________________________________
	126	Double_t
	127	AliFMDMultCuts::GetMultCut(UShort_t d, Char_t r, Int_t ieta,
	128	Bool_t errors) const
	129	{
	130	//
	131	// Get the multiplicity cut. If the user has set fMultCut (via
	132	// SetMultCut) then that value is used. If not, then the lower
	133	// value of the fit range for the enery loss fits is returned.
	134	//
	135	// Return:
	136	// Lower cut on multiplicity
	137	//
7095962e	138	DGUARD(fDebug, 5, "Get mult cut for FMD%d%c (method %d) @ etabin=%d",
7d596e9b	139	d, r, fMethod, ieta);
	140	Double_t param = GetCutParam(d, r);
	141	if (param < 0) {
	142	Warning("GetMultCut", "Got bad cut parameter for FMD%d%c ieta=%d",
	143	d, r, ieta);
	144	return -kBad;
	145	}
	146
	147	// If we're using a fixed cut, just return
	148	if (fMethod == kFixed) {
	149	DMSG(fDebug, 5, "-> %8.4f", param);
	150	return param;
	151	}
bfcbb65a	152
7d596e9b	153	// Bad value
	154	Double_t rcut = -kBad;
	155
	156	// Get the energy loss fits
	157	AliForwardCorrectionManager& fcm =
	158	AliForwardCorrectionManager::Instance();
	159	const AliFMDCorrELossFit* fits = fcm.GetELossFit();
	160	if (fits) {
	161	switch (fMethod) {
	162	case kMPVFraction:
	163	// Return fMPVFraction * mpv
	164	rcut = fits->GetLowerBound(d, r, ieta, param); break;
	165	case kLandauWidth:
	166	// Return MPV - fNXi * xi
	167	rcut = fits->GetLowerBound(d, r, ieta, param, errors,false);
	168	break;
	169	case kLandauSigmaWidth:
	170	// Return MPV - fNXi * xi
	171	rcut = fits->GetLowerBound(d, r, ieta, param, errors,true);
	172	break;
	173	case kProbability:
	174	// Return probability cut
	175	rcut = fits->GetLowerBound(d, r, ieta, param, true); break;
	176	default:
	177	// Return lower fit boundary
	178	rcut = fits->GetLowCut(); break;
7095962e	179	}
7095962e	180	}
7d596e9b	181	else
	182	Warning("GetMultCut", "No energy loss fits obtained from manager");
	183
7095962e CHC	184	DMSG(fDebug, 5, "-> %8.4f", rcut);
	185
	186	return rcut;
bfcbb65a	187	}
	188
	189	//____________________________________________________________________
	190	Double_t
	191	AliFMDMultCuts::GetMultCut(UShort_t d, Char_t r, Double_t eta,
	192	Bool_t errors) const
	193	{
	194	//
	195	// Get the multiplicity cut. If the user has set fMultCut (via
	196	// SetMultCut) then that value is used. If not, then the lower
	197	// value of the fit range for the enery loss fits is returned.
	198	//
	199	// Return:
	200	// Lower cut on multiplicity
	201	//
7095962e CHC	202	DGUARD(fDebug, 5, "Get mult cut for FMD%d%c @ eta=%8.4f",
7095962e CHC	203	d, r, eta);
bfcbb65a	204	AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
8449e3e0	205	const AliFMDCorrELossFit* fits = fcm.GetELossFit();
e441e255	206	Int_t iEta = fits ? fits->FindEtaBin(eta) : 1;
7095962e	207	DMSG(fDebug, 5, "bin=%4d", iEta);
bfcbb65a	208	return GetMultCut(d, r, iEta, errors);
bfcbb65a	209	}
c514a160	210	//____________________________________________________________________
7d596e9b	211	const char*
7d596e9b	212	AliFMDMultCuts::GetMethodString(Bool_t latex) const
c514a160	213	{
7d596e9b	214	return Method2String(fMethod, latex);
c514a160	215	}
7d596e9b	216
c514a160	217	//____________________________________________________________________
c514a160	218	const char*
7d596e9b	219	AliFMDMultCuts::Method2String(EMethod method, Bool_t latex)
c514a160	220	{
7d596e9b	221	switch (method) {
	222	case kFixed:
	223	return latex ? "c=X" : "fixed value";
	224	case kMPVFraction:
	225	return latex ? "c=X#times#Delta_{p}":"fraction of MPV";
	226	case kFitRange:
	227	return latex ? "range" : "c: lower fit bound";
	228	case kLandauWidth:
	229	return latex ? "c=#Delta_{p}-X#times#xi" : "landau width";
	230	case kLandauSigmaWidth:
	231	return latex ? "c=#Delta_{p}-X#times(#xi+#sigma)" : "landau+sigma width";
	232	case kProbability:
	233	return latex ? "c:P(#Delta<c)<X" : "probability";
c514a160	234	}
7d596e9b	235	return latex ? "c:?" : "unknown";
	236	}
	237	//____________________________________________________________________
	238	AliFMDMultCuts::EMethod
	239	AliFMDMultCuts::String2Method(const char* str)
	240	{
	241	TString m(str);
	242	if (m.EqualTo("fixed value") \|\| m.Contains("fix"))
	243	return kFixed;
	244	else if (m.EqualTo("fraction of mpv") \|\| m.Contains("mpv"))
	245	return kMPVFraction;
	246	else if (m.EqualTo("fit range") \|\| m.Contains("fit"))
	247	return kFitRange;
	248	else if (m.EqualTo("landau width") \|\| m.Contains("xi") \|\|
	249	m.Contains("width")) return kLandauWidth;
	250	else if (m.EqualTo("landau+sigma width") \|\| m.Contains("sig"))
	251	return kLandauSigmaWidth;
	252	else if (m.EqualTo("probability") \|\| m.Contains("prob"))
	253	return kProbability;
	254	return kFixed;
7095962e CHC	255	}
	256
	257	//____________________________________________________________________
	258	void
	259	AliFMDMultCuts::FillHistogram(TH2* h) const
	260	{
	261	DGUARD(fDebug, 5, "Fill Histogram %s with cuts", h->GetName());
7d596e9b	262	// AliInfoF("Caching multiplicity cuts (%s)", h->GetName());
7095962e CHC	263	TAxis* yAxis = h->GetYaxis();
	264	for (Int_t iy = 1; iy <= yAxis->GetNbins(); iy++) {
	265	TString lab(yAxis->GetBinLabel(iy));
	266	lab.Remove(0,3);
	267	UShort_t det = lab.Atoi();
	268	Char_t rng = lab[1];
	269	// Printf("Filling for FMD%d%c (bin # %d) %s", det, rng, iy, lab.Data());
7d596e9b	270	DMSG(fDebug, 5, "FMD%d%c", det, rng);
7d596e9b	271	// AliInfoF("FMD%d%c", det, rng);
7095962e CHC	272	for (Int_t ix = 1; ix <= h->GetNbinsX(); ix++) {
	273	Double_t eta = h->GetXaxis()->GetBinCenter(ix);
	274	Double_t c = GetMultCut(det, rng, eta, false);
7d596e9b	275	DMSG(fDebug, 10, "FMD%s bin=%4d -> eta=%8.4f -> %8.4f",
7095962e CHC	276	lab.Data(), ix, eta, c);
	277	// Double_t c = GetMultCut(det, rng, ix, false);
	278	if (c > 0) h->SetBinContent(ix, iy, c);
	279	}
	280	}
	281	}
c514a160	282
bfcbb65a	283	//____________________________________________________________________
	284	void
	285	AliFMDMultCuts::Output(TList* l, const char* name) const
	286	{
	287	TList* ll = l;
	288	if (name && name[0] != '\0') {
	289	ll = new TList;
	290	ll->SetName(name);
	291	ll->SetOwner();
	292	l->Add(ll);
	293	}
	294
c514a160	295
7d596e9b	296	ll->Add(AliForwardUtil::MakeParameter("method", UShort_t(fMethod)));
	297	ll->Add(AliForwardUtil::MakeParameter("fmd1i", fCuts[0]));
	298	ll->Add(AliForwardUtil::MakeParameter("fmd2i", fCuts[1]));
	299	ll->Add(AliForwardUtil::MakeParameter("fmd2o", fCuts[2]));
	300	ll->Add(AliForwardUtil::MakeParameter("fmd3i", fCuts[3]));
	301	ll->Add(AliForwardUtil::MakeParameter("fmd3o", fCuts[4]));
241cca4d	302	}
	303	//____________________________________________________________________
	304	Bool_t
	305	AliFMDMultCuts::Input(TList* l, const char* name)
	306	{
	307	if (!l) return false;
	308	TList* ll = l;
	309	if (name && name[0] != '\0') {
	310	ll = static_cast<TList*>(l->FindObject(name));
	311	}
	312	if (!ll) return false;
	313
7d596e9b	314	TObject* meth = ll->FindObject("method");
	315	TObject* fmd1i = ll->FindObject("fmd1i");
	316	TObject* fmd2i = ll->FindObject("fmd2i");
	317	TObject* fmd2o = ll->FindObject("fmd2o");
	318	TObject* fmd3i = ll->FindObject("fmd3i");
	319	TObject* fmd3o = ll->FindObject("fmd3o");
	320
	321	UShort_t methNum = 0;
	322
	323	AliForwardUtil::GetParameter(meth, methNum);
	324	switch (methNum) {
	325	case 0: fMethod = kFixed; break;
	326	case 1: fMethod = kMPVFraction; break;
	327	case 2: fMethod = kFitRange; break;
	328	case 3: fMethod = kLandauWidth; break;
	329	case 4: fMethod = kLandauSigmaWidth; break;
	330	case 5: fMethod = kProbability; break;
	331	}
	332
	333	AliForwardUtil::GetParameter(fmd1i, fCuts[0]);
	334	AliForwardUtil::GetParameter(fmd2i, fCuts[1]);
	335	AliForwardUtil::GetParameter(fmd2o, fCuts[2]);
	336	AliForwardUtil::GetParameter(fmd3i, fCuts[3]);
	337	AliForwardUtil::GetParameter(fmd3o, fCuts[4]);
241cca4d	338
241cca4d	339	return true;
bfcbb65a	340	}
c8b1a7db	341	#define PF(N,V,...) \
	342	AliForwardUtil::PrintField(N,V, ## __VA_ARGS__)
	343	#define PFB(N,FLAG) \
	344	do { \
	345	AliForwardUtil::PrintName(N); \
	346	std::cout << std::boolalpha << (FLAG) << std::noboolalpha << std::endl; \
	347	} while(false)
	348	#define PFV(N,VALUE) \
	349	do { \
	350	AliForwardUtil::PrintName(N); \
	351	std::cout << (VALUE) << std::endl; } while(false)
bfcbb65a	352
	353	//____________________________________________________________________
	354	void
	355	AliFMDMultCuts::Print(Option_t*) const
	356	{
c8b1a7db	357	gROOT->IncreaseDirLevel();
c8b1a7db	358	PFV("Method used", GetMethodString());
c8b1a7db	359	gROOT->IncreaseDirLevel();
7d596e9b	360	PFV("FMD1i", GetCutParam(1,'I'));
	361	PFV("FMD2i", GetCutParam(2,'I'));
	362	PFV("FMD2o", GetCutParam(2,'O'));
	363	PFV("FMD3i", GetCutParam(3,'I'));
	364	PFV("FMD3o", GetCutParam(3,'O'));
c8b1a7db	365	gROOT->DecreaseDirLevel();
c8b1a7db	366	gROOT->DecreaseDirLevel();
bfcbb65a	367	}
	368	//____________________________________________________________________
	369	//
	370	// EOF
	371	//