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