[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnCutStd.cxx

//
// Class AliRsnCutStd
//
// General implementation of a single cut strategy, which can be:
// - a value contained in a given interval  [--> IsBetween()   ]
// - a value equal to a given reference     [--> MatchesValue()]
//
// In all cases, the reference value(s) is (are) given as data members
// and each kind of cut requires a given value type (Int, UInt, Double),
// but the cut check procedure is then automatized and chosen thanks to
// an enumeration of the implemented cut types.
// At the end, the user (or any other point which uses this object) has
// to use the method IsSelected() to check if this cut has been passed.
//
// authors: Martin Vala (martin.vala@cern.ch)
//          Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
//

#include "TParticle.h"
#include "TMath.h"

#include "AliRsnDaughter.h"
#include "AliRsnEvent.h"
#include "AliRsnPairParticle.h"

#include "AliRsnCutStd.h"

ClassImp(AliRsnCutStd)

//_________________________________________________________________________________________________
AliRsnCutStd::AliRsnCutStd() :
    AliRsnCut(),
    fType(kLastType),
    fUseMC(kFALSE),
    fMass(0.0)
{
//
// Default constructor.
//
}

//_________________________________________________________________________________________________
AliRsnCutStd::AliRsnCutStd
(const char *name, EType type, Int_t val1, Int_t val2, Bool_t useMC) :
    AliRsnCut(name, val1, val2),
    fType(type),
    fUseMC(useMC),
    fMass(0.0)
{
//
// Main constructor.
// Checks also that cut values are given in the correct type,
// in order to avoid that one passes, for example, a value which should be double
// but is interpreted as integer due to the overloading of constructors
//

  switch (fType) {
    // int
  case kMult:
  case kMultDiff:
  case kKink:
  case kKinkMother:
  case kAssignedPID:
  case kTruePID:
  case kRequiredPID:
  case kCharge:
    break;
    // ulong
  case kStatus:
    if (fVarType != kULong) {
      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
      SetRange((ULong_t)val1, (ULong_t)val2);
      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' ULONG range = %d, %d", GetName(), fMinU, fMaxU));
    }
    break;
    // double
  case kP:
  case kPt:
  case kEta:
  case kY:
  case kThetaDeg:
  case kDr:
  case kDz:
  case kTPCsignal:
  case kMultDiffRel:
  case kVzDiff:
    if (fVarType != kDouble) {
      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
      SetRange((Double_t)val1, (Double_t)val2);
      AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
    }
    break;
    // other cuts are not based on a value, so no problem
  default:
    break;
  }
}

//_________________________________________________________________________________________________
AliRsnCutStd::AliRsnCutStd
(const char *name, EType type, ULong_t val1, ULong_t val2, Bool_t useMC) :
    AliRsnCut(name, val1, val2),
    fType(type),
    fUseMC(useMC),
    fMass(0.0)
{
//
// Main constructor.
// Checks also that cut values are given in the correct type,
// in order to avoid that one passes, for example, a value which should be double
// but is interpreted as integer due to the overloading of constructors
//

  switch (fType) {
    // int
  case kMult:
  case kMultDiff:
  case kKink:
  case kKinkMother:
  case kAssignedPID:
  case kTruePID:
  case kRequiredPID:
  case kCharge:
    if (fVarType != kInt) {
      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
      SetRange((Int_t)val1, (Int_t)val2);
      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
    }
    break;
    // ulong
  case kStatus:
    break;
    // double
  case kP:
  case kPt:
  case kEta:
  case kY:
  case kThetaDeg:
  case kDr:
  case kDz:
  case kTPCsignal:
  case kMultDiffRel:
  case kVzDiff:
    if (fVarType != kDouble) {
      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
      SetRange((Double_t)val1, (Double_t)val2);
      AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
    }
    break;
    // other cuts are not based on a value, so no problem
  default:
    break;
  }
}

//_________________________________________________________________________________________________
AliRsnCutStd::AliRsnCutStd
(const char *name, EType type, Double_t val1, Double_t val2, Bool_t useMC) :
    AliRsnCut(name, val1, val2),
    fType(type),
    fUseMC(useMC),
    fMass(0.0)
{
//
// Main constructor.
// Checks also that cut values are given in the correct type,
// in order to avoid that one passes, for example, a value which should be double
// but is interpreted as integer due to the overloading of constructors
//

  switch (fType) {
    // int
  case kMult:
  case kMultDiff:
  case kKink:
  case kKinkMother:
  case kAssignedPID:
  case kTruePID:
  case kRequiredPID:
  case kCharge:
    if (fVarType != kInt) {
      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
      SetRange((Int_t)val1, (Int_t)val2);
      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
    }
    break;
    // ulong
  case kStatus:
    if (fVarType != kULong) {
      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
      SetRange((ULong_t)val1, (ULong_t)val2);
      AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' ULONG range = %d, %d", GetName(), fMinU, fMaxU));
    }
    break;
    // double
  case kP:
  case kPt:
  case kEta:
  case kY:
  case kThetaDeg:
  case kDr:
  case kDz:
  case kTPCsignal:
  case kMultDiffRel:
  case kVzDiff:
    break;
    // other cuts are not based on a value, so no problem
  default:
    break;
  }
}

//_________________________________________________________________________________________________
Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnDaughter * const track)
{
//
// Cut checker.
//

  // coherence check
  if (tgt != AliRsnCut::kParticle) {
    AliError(Form("Wrong target. Skipping cut", GetName()));
    return kTRUE;
  }


  // if MC info is required, try to retrieve the TParticle:
  // if it is not present, the cut is skipped
  // this avoids to raise a seg-fault when accessing the NULL TParticle object
  TParticle *part = 0x0;
  if (fUseMC) {
    part = track->GetParticle();
    if (!part) {
      AliError("Required MC info but it is not present. Cut Skipped.");
      return kTRUE;
    }
  }

  // loop on allowed possibilities
  switch (fType) {
  case kP:
    fCutValueD = fUseMC ? part->P() : track->P();
    return OkRange();
  case kPt:
    fCutValueD = fUseMC ? part->Pt() : track->Pt();
    return OkRange();
  case kThetaDeg:
    fCutValueD = track->ThetaDeg();
    return OkRange();
  case kEta:
    fCutValueD = fUseMC ? part->Eta() : track->Eta();
    return OkRange();
  case kDr:
    fCutValueD = track->Dr();
    return OkRange();
  case kDz:
    fCutValueD = track->Dz();
    return OkRange();
  case kStatus:
    fCutValueU = track->GetStatus();
    return OkValue();
  case kKink:
    fCutValueI = track->IsKink();
    return OkValue();
  case kKinkMother:
    fCutValueI = track->IsKinkMother();
    return OkValue();
  case kCharge:
    fCutValueI = (Int_t)track->Charge();
    return OkValue();
  case kTruePID:
    fCutValueI = (Int_t)track->PerfectPID();
    return OkValue();
  case kAssignedPID:
    fCutValueI = (Int_t)track->AssignedPID();
    return OkValue();
  case kRequiredPID:
    fCutValueI = (Int_t)track->RequiredPID();
    return OkValue();
  case kRealisticPID:
    fCutValueI = (Int_t)track->RealisticPID();
    return OkValue();
  case kPairIndex:
    fCutValueI = track->PairIndex();
    return OkValue();
  case kTruePIDMatch:
    return (track->PerfectPID() == track->RequiredPID());
  case kRealisticPIDMatch:
    return (track->RealisticPID() == track->RequiredPID());
  default:
    AliWarning(Form("Value %d is not included in available cuts for DAUGHTER. Cut skipped.", fType));
    return kTRUE;
  }
}

//_________________________________________________________________________________________________
Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnPairParticle * const pair)
{
//
// Cut checker
//

  // coherence check
  if (tgt != AliRsnCut::kPair) {
    AliError(Form("Wrong target. Skipping cut", GetName()));
    return kTRUE;
  }

  // loop on allowed possibilities
  switch (fType) {
  case kP:
    fCutValueD = (fUseMC ? pair->GetPMC() : pair->GetP());
    return OkRange();
  case kPt:
    fCutValueD = (fUseMC ? pair->GetPtMC() : pair->GetPt());
    return OkRange();
  case kEta:
    fCutValueD = (fUseMC ? pair->GetEtaMC() : pair->GetEta());
    return OkRange();
  case kY:
    fCutValueD = (fUseMC ? pair->GetYMC(fMass) : pair->GetY(fMass));
    return OkRange();
  case kSameLabel:
    return pair->IsLabelEqual();
  case kTruePair:
    fCutValueI = TMath::Abs(pair->CommonMother());
    return OkValue();
  default:
    AliWarning(Form("Value %d is not included in available cuts for PAIR. Cut skipped.", fType));
    return kTRUE;
  }
}

//_________________________________________________________________________________________________
Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent * const event)
{
//
// Cut checker
//

  // coherence check
  if (tgt != AliRsnCut::kEvent) {
    AliError(Form("Wrong target. Skipping cut", GetName()));
    return kTRUE;
  }

  // loop on allowed possibilities
  switch (fType) {
  case kMult:
    fCutValueI = event->GetMultiplicity();
    return OkRange();
  default:
    AliWarning(Form("Value %d is not included in available cuts for EVENT. Cut skipped.", fType));
    return kTRUE;
  }
}

//_________________________________________________________________________________________________
Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent * const ev1, AliRsnEvent * const ev2)
{
//
// Cut checker
//

  // coherence check
  if (tgt != AliRsnCut::kMixEvent) {
    AliError(Form("Wrong target. Skipping cut", GetName()));
    return kTRUE;
  }

  // loop on allowed possibilities
  Double_t mult1, mult2;
  switch (fType) {
  case kMultDiff:
    fCutValueI = TMath::Abs(ev1->GetMultiplicity() - ev2->GetMultiplicity());
    return OkRange();
  case kMultDiffRel:
    mult1 = (Double_t)ev1->GetMultiplicity();
    mult2 = (Double_t)ev2->GetMultiplicity();
    if (mult1 == 0.0  && mult2 == 0.0) return kTRUE;
    fCutValueD = 100.0 * TMath::Abs(mult1 - mult2) / TMath::Max(mult1, mult2); // in %
    return OkRange();
  case kVzDiff:
    fCutValueD = TMath::Abs(ev1->GetVz() - ev2->GetVz());
    return OkRange();
  default:
    AliWarning(Form("Value %d is not included in available cuts for MIXEVENT. Cut skipped.", fType));
    return kTRUE;
  }
}
Commit	Line	Data
5eb970a4	1	//
	2	// Class AliRsnCutStd
	3	//
	4	// General implementation of a single cut strategy, which can be:
	5	// - a value contained in a given interval [--> IsBetween() ]
	6	// - a value equal to a given reference [--> MatchesValue()]
	7	//
	8	// In all cases, the reference value(s) is (are) given as data members
	9	// and each kind of cut requires a given value type (Int, UInt, Double),
	10	// but the cut check procedure is then automatized and chosen thanks to
	11	// an enumeration of the implemented cut types.
	12	// At the end, the user (or any other point which uses this object) has
	13	// to use the method IsSelected() to check if this cut has been passed.
	14	//
	15	// authors: Martin Vala (martin.vala@cern.ch)
	16	// Alberto Pulvirenti (alberto.pulvirenti@ct.infn.it)
	17	//
4fbb2459	18
5eb970a4	19	#include "TParticle.h"
	20	#include "TMath.h"
	21
5eb970a4	22	#include "AliRsnDaughter.h"
	23	#include "AliRsnEvent.h"
	24	#include "AliRsnPairParticle.h"
	25
	26	#include "AliRsnCutStd.h"
	27
	28	ClassImp(AliRsnCutStd)
	29
	30	//_________________________________________________________________________________________________
	31	AliRsnCutStd::AliRsnCutStd() :
4fbb2459	32	AliRsnCut(),
4fbb2459	33	fType(kLastType),
eb079724	34	fUseMC(kFALSE),
eb079724	35	fMass(0.0)
5eb970a4	36	{
	37	//
	38	// Default constructor.
	39	//
	40	}
	41
	42	//_________________________________________________________________________________________________
	43	AliRsnCutStd::AliRsnCutStd
	44	(const char *name, EType type, Int_t val1, Int_t val2, Bool_t useMC) :
4fbb2459	45	AliRsnCut(name, val1, val2),
4fbb2459	46	fType(type),
eb079724	47	fUseMC(useMC),
eb079724	48	fMass(0.0)
5eb970a4	49	{
	50	//
	51	// Main constructor.
	52	// Checks also that cut values are given in the correct type,
	53	// in order to avoid that one passes, for example, a value which should be double
	54	// but is interpreted as integer due to the overloading of constructors
	55	//
	56
4fbb2459	57	switch (fType) {
5eb970a4	58	// int
4fbb2459	59	case kMult:
	60	case kMultDiff:
	61	case kKink:
	62	case kKinkMother:
	63	case kAssignedPID:
	64	case kTruePID:
	65	case kRequiredPID:
	66	case kCharge:
	67	break;
5eb970a4	68	// ulong
4fbb2459	69	case kStatus:
	70	if (fVarType != kULong) {
	71	AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
	72	SetRange((ULong_t)val1, (ULong_t)val2);
	73	AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' ULONG range = %d, %d", GetName(), fMinU, fMaxU));
	74	}
	75	break;
5eb970a4	76	// double
4fbb2459	77	case kP:
	78	case kPt:
	79	case kEta:
eb079724	80	case kY:
4fbb2459	81	case kThetaDeg:
	82	case kDr:
	83	case kDz:
	84	case kTPCsignal:
	85	case kMultDiffRel:
	86	case kVzDiff:
	87	if (fVarType != kDouble) {
	88	AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
	89	SetRange((Double_t)val1, (Double_t)val2);
	90	AliWarning(Form("[INT CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
	91	}
	92	break;
5eb970a4	93	// other cuts are not based on a value, so no problem
4fbb2459	94	default:
4fbb2459	95	break;
5eb970a4	96	}
	97	}
	98
	99	//_________________________________________________________________________________________________
	100	AliRsnCutStd::AliRsnCutStd
	101	(const char *name, EType type, ULong_t val1, ULong_t val2, Bool_t useMC) :
4fbb2459	102	AliRsnCut(name, val1, val2),
4fbb2459	103	fType(type),
eb079724	104	fUseMC(useMC),
eb079724	105	fMass(0.0)
5eb970a4	106	{
	107	//
	108	// Main constructor.
	109	// Checks also that cut values are given in the correct type,
	110	// in order to avoid that one passes, for example, a value which should be double
	111	// but is interpreted as integer due to the overloading of constructors
	112	//
	113
4fbb2459	114	switch (fType) {
5eb970a4	115	// int
4fbb2459	116	case kMult:
	117	case kMultDiff:
	118	case kKink:
	119	case kKinkMother:
	120	case kAssignedPID:
	121	case kTruePID:
	122	case kRequiredPID:
	123	case kCharge:
	124	if (fVarType != kInt) {
	125	AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
	126	SetRange((Int_t)val1, (Int_t)val2);
	127	AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
	128	}
	129	break;
5eb970a4	130	// ulong
4fbb2459	131	case kStatus:
4fbb2459	132	break;
5eb970a4	133	// double
4fbb2459	134	case kP:
	135	case kPt:
	136	case kEta:
eb079724	137	case kY:
4fbb2459	138	case kThetaDeg:
	139	case kDr:
	140	case kDz:
	141	case kTPCsignal:
	142	case kMultDiffRel:
	143	case kVzDiff:
	144	if (fVarType != kDouble) {
	145	AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' is based on DOUBLE. Casting values to DOUBLE", GetName()));
	146	SetRange((Double_t)val1, (Double_t)val2);
	147	AliWarning(Form("[ULONG CONSTRUCTOR] Cut '%s' DOUBLE range = %f, %f", GetName(), fMinD, fMaxD));
	148	}
	149	break;
5eb970a4	150	// other cuts are not based on a value, so no problem
4fbb2459	151	default:
4fbb2459	152	break;
5eb970a4	153	}
	154	}
	155
	156	//_________________________________________________________________________________________________
	157	AliRsnCutStd::AliRsnCutStd
	158	(const char *name, EType type, Double_t val1, Double_t val2, Bool_t useMC) :
4fbb2459	159	AliRsnCut(name, val1, val2),
4fbb2459	160	fType(type),
eb079724	161	fUseMC(useMC),
eb079724	162	fMass(0.0)
5eb970a4	163	{
	164	//
	165	// Main constructor.
	166	// Checks also that cut values are given in the correct type,
	167	// in order to avoid that one passes, for example, a value which should be double
	168	// but is interpreted as integer due to the overloading of constructors
	169	//
	170
4fbb2459	171	switch (fType) {
5eb970a4	172	// int
4fbb2459	173	case kMult:
	174	case kMultDiff:
	175	case kKink:
	176	case kKinkMother:
	177	case kAssignedPID:
	178	case kTruePID:
	179	case kRequiredPID:
	180	case kCharge:
	181	if (fVarType != kInt) {
	182	AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on INT. Casting values to INT", GetName()));
	183	SetRange((Int_t)val1, (Int_t)val2);
	184	AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' INT range = %d, %d", GetName(), fMinI, fMaxI));
	185	}
	186	break;
5eb970a4	187	// ulong
4fbb2459	188	case kStatus:
	189	if (fVarType != kULong) {
	190	AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' is based on ULONG. Casting values to ULONG", GetName()));
	191	SetRange((ULong_t)val1, (ULong_t)val2);
	192	AliWarning(Form("[DOUBLE CONSTRUCTOR] Cut '%s' ULONG range = %d, %d", GetName(), fMinU, fMaxU));
	193	}
	194	break;
5eb970a4	195	// double
4fbb2459	196	case kP:
	197	case kPt:
	198	case kEta:
eb079724	199	case kY:
4fbb2459	200	case kThetaDeg:
	201	case kDr:
	202	case kDz:
	203	case kTPCsignal:
	204	case kMultDiffRel:
	205	case kVzDiff:
	206	break;
5eb970a4	207	// other cuts are not based on a value, so no problem
4fbb2459	208	default:
4fbb2459	209	break;
5eb970a4	210	}
	211	}
	212
	213	//_________________________________________________________________________________________________
4fbb2459	214	Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnDaughter * const track)
5eb970a4	215	{
	216	//
	217	// Cut checker.
	218	//
	219
	220	// coherence check
4fbb2459	221	if (tgt != AliRsnCut::kParticle) {
5eb970a4	222	AliError(Form("Wrong target. Skipping cut", GetName()));
	223	return kTRUE;
	224	}
	225
	226
	227	// if MC info is required, try to retrieve the TParticle:
	228	// if it is not present, the cut is skipped
	229	// this avoids to raise a seg-fault when accessing the NULL TParticle object
	230	TParticle *part = 0x0;
	231	if (fUseMC) {
	232	part = track->GetParticle();
	233	if (!part) {
	234	AliError("Required MC info but it is not present. Cut Skipped.");
	235	return kTRUE;
	236	}
	237	}
	238
	239	// loop on allowed possibilities
4fbb2459	240	switch (fType) {
	241	case kP:
	242	fCutValueD = fUseMC ? part->P() : track->P();
	243	return OkRange();
	244	case kPt:
	245	fCutValueD = fUseMC ? part->Pt() : track->Pt();
	246	return OkRange();
	247	case kThetaDeg:
	248	fCutValueD = track->ThetaDeg();
	249	return OkRange();
	250	case kEta:
	251	fCutValueD = fUseMC ? part->Eta() : track->Eta();
	252	return OkRange();
	253	case kDr:
	254	fCutValueD = track->Dr();
	255	return OkRange();
	256	case kDz:
	257	fCutValueD = track->Dz();
	258	return OkRange();
	259	case kStatus:
	260	fCutValueU = track->GetStatus();
	261	return OkValue();
	262	case kKink:
	263	fCutValueI = track->IsKink();
	264	return OkValue();
	265	case kKinkMother:
	266	fCutValueI = track->IsKinkMother();
	267	return OkValue();
	268	case kCharge:
	269	fCutValueI = (Int_t)track->Charge();
	270	return OkValue();
	271	case kTruePID:
	272	fCutValueI = (Int_t)track->PerfectPID();
	273	return OkValue();
	274	case kAssignedPID:
	275	fCutValueI = (Int_t)track->AssignedPID();
	276	return OkValue();
	277	case kRequiredPID:
	278	fCutValueI = (Int_t)track->RequiredPID();
	279	return OkValue();
	280	case kRealisticPID:
	281	fCutValueI = (Int_t)track->RealisticPID();
413bbf44	282	return OkValue();
	283	case kPairIndex:
	284	fCutValueI = track->PairIndex();
	285	return OkValue();
4fbb2459	286	case kTruePIDMatch:
	287	return (track->PerfectPID() == track->RequiredPID());
	288	case kRealisticPIDMatch:
	289	return (track->RealisticPID() == track->RequiredPID());
	290	default:
	291	AliWarning(Form("Value %d is not included in available cuts for DAUGHTER. Cut skipped.", fType));
	292	return kTRUE;
5eb970a4	293	}
	294	}
	295
	296	//_________________________________________________________________________________________________
4fbb2459	297	Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnPairParticle * const pair)
5eb970a4	298	{
	299	//
	300	// Cut checker
	301	//
	302
	303	// coherence check
4fbb2459	304	if (tgt != AliRsnCut::kPair) {
5eb970a4	305	AliError(Form("Wrong target. Skipping cut", GetName()));
	306	return kTRUE;
	307	}
	308
	309	// loop on allowed possibilities
4fbb2459	310	switch (fType) {
	311	case kP:
	312	fCutValueD = (fUseMC ? pair->GetPMC() : pair->GetP());
	313	return OkRange();
	314	case kPt:
	315	fCutValueD = (fUseMC ? pair->GetPtMC() : pair->GetPt());
	316	return OkRange();
	317	case kEta:
	318	fCutValueD = (fUseMC ? pair->GetEtaMC() : pair->GetEta());
	319	return OkRange();
eb079724	320	case kY:
	321	fCutValueD = (fUseMC ? pair->GetYMC(fMass) : pair->GetY(fMass));
	322	return OkRange();
4fbb2459	323	case kSameLabel:
	324	return pair->IsLabelEqual();
	325	case kTruePair:
	326	fCutValueI = TMath::Abs(pair->CommonMother());
	327	return OkValue();
	328	default:
	329	AliWarning(Form("Value %d is not included in available cuts for PAIR. Cut skipped.", fType));
	330	return kTRUE;
5eb970a4	331	}
	332	}
	333
	334	//_________________________________________________________________________________________________
4fbb2459	335	Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent * const event)
5eb970a4	336	{
	337	//
	338	// Cut checker
	339	//
	340
	341	// coherence check
4fbb2459	342	if (tgt != AliRsnCut::kEvent) {
5eb970a4	343	AliError(Form("Wrong target. Skipping cut", GetName()));
	344	return kTRUE;
	345	}
	346
	347	// loop on allowed possibilities
4fbb2459	348	switch (fType) {
	349	case kMult:
	350	fCutValueI = event->GetMultiplicity();
	351	return OkRange();
	352	default:
	353	AliWarning(Form("Value %d is not included in available cuts for EVENT. Cut skipped.", fType));
	354	return kTRUE;
5eb970a4	355	}
	356	}
	357
	358	//_________________________________________________________________________________________________
4fbb2459	359	Bool_t AliRsnCutStd::IsSelected(ETarget tgt, AliRsnEvent * const ev1, AliRsnEvent * const ev2)
5eb970a4	360	{
	361	//
	362	// Cut checker
	363	//
	364
	365	// coherence check
4fbb2459	366	if (tgt != AliRsnCut::kMixEvent) {
5eb970a4	367	AliError(Form("Wrong target. Skipping cut", GetName()));
	368	return kTRUE;
	369	}
	370
	371	// loop on allowed possibilities
	372	Double_t mult1, mult2;
4fbb2459	373	switch (fType) {
	374	case kMultDiff:
	375	fCutValueI = TMath::Abs(ev1->GetMultiplicity() - ev2->GetMultiplicity());
	376	return OkRange();
	377	case kMultDiffRel:
	378	mult1 = (Double_t)ev1->GetMultiplicity();
	379	mult2 = (Double_t)ev2->GetMultiplicity();
	380	if (mult1 == 0.0 && mult2 == 0.0) return kTRUE;
	381	fCutValueD = 100.0 * TMath::Abs(mult1 - mult2) / TMath::Max(mult1, mult2); // in %
	382	return OkRange();
	383	case kVzDiff:
	384	fCutValueD = TMath::Abs(ev1->GetVz() - ev2->GetVz());
	385	return OkRange();
	386	default:
	387	AliWarning(Form("Value %d is not included in available cuts for MIXEVENT. Cut skipped.", fType));
	388	return kTRUE;
5eb970a4	389	}
5eb970a4	390	}