[u/mrichter/AliRoot.git] / EVGEN / AliDimuCombinator.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/*
$Log$
Revision 1.5  2000/06/09 20:35:32  morsch
All coding rule violations except RS3 corrected

Revision 1.4  2000/03/20 18:03:24  morsch
Change muon particle code to PDG code.

Revision 1.3  1999/09/29 09:24:08  fca
Introduction of the Copyright and cvs Log

*/

//
//
//
//
#include "AliDimuCombinator.h" 
#include "AliPDG.h" 
#include <TRandom.h>
#include <TClonesArray.h>

//
ClassImp(AliDimuCombinator)
    AliDimuCombinator::AliDimuCombinator(TClonesArray* Partarray) 
{
// Constructor
    fPartArray=Partarray;
    fNParticle=fPartArray->GetEntriesFast();
    
    fimuon1 =0;
    fimuon2 =0;
    fmuon1  =0;
    fmuon2  =0;
    fimin1  = 0;
    fimin2  = 0;
    fimax1  = fNParticle;
    fimax2  = fNParticle;
    fPtMin  =0;
    fEtaMin =-10;
    fEtaMax =-10;
    fRate1=1.;
    fRate2=1.;
}

AliDimuCombinator::AliDimuCombinator(const AliDimuCombinator & combinator)
{
// copy constructor
}


//
//                       Iterators
// 
TParticle* AliDimuCombinator::FirstMuon()
{
// Single muon iterator: initialisation
    fimuon1=fimin1;
    fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
    while(Type(fmuon1)!=kMuonPlus && Type(fmuon1)!=kMuonMinus) {
	fimuon1++;
	if (fimuon1 >= fimax1) {fmuon1=0; break;}
	fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
    }
    return fmuon1;
}

TParticle* AliDimuCombinator::FirstMuonSelected()
{
// Single selected muon iterator: initialisation
    TParticle * muon=FirstMuon();
    while(muon!=0 && !Selected(muon)) {muon=NextMuon();}
    return muon;
}


TParticle* AliDimuCombinator::NextMuon()
{
// Single muon iterator: increment
    fimuon1++;
    if (fimuon1>=fNParticle) {fmuon1 = 0; return fmuon1;}
    
    fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
    while(Type(fmuon1)!=kMuonPlus && Type(fmuon1)!=kMuonMinus) {
	fimuon1++;
	if (fimuon1>=fimax1) {fmuon1 = 0; break;}
	fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
    }
    return fmuon1;
}

TParticle* AliDimuCombinator::NextMuonSelected()
{
// Single selected muon iterator: increment
    TParticle * muon=NextMuon();
    while(muon !=0 && !Selected(muon)) {muon=NextMuon();}
    return muon;
}


void AliDimuCombinator::FirstPartner()
{
// Helper for  dimuon iterator: initialisation
    if (fimin1==fimin2) {
	fimuon2=fimuon1+1;
    } else {
	fimuon2=fimin2;
    }
    if (fimuon2 >= fimax2) {fmuon2=0; return;}
    fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
    while(Type(fmuon2)!=kMuonPlus && Type(fmuon2)!=kMuonMinus) {
	fimuon2++;
	if (fimuon2 >= fimax2) {fmuon2=0; break;}
	fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
    }
}

void AliDimuCombinator::FirstPartnerSelected()
{
// Helper for selected dimuon iterator: initialisation
    FirstPartner();
    while(fmuon2 !=0 && !Selected(fmuon2)) {NextPartner();}
}


void AliDimuCombinator::NextPartner()
{
// Helper for dimuon iterator: increment    
    fimuon2++;
    if (fimuon2>=fimax2) {fmuon2 = 0; return;}
    
    
    fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
    
    while(Type(fmuon2)!=kMuonPlus && Type(fmuon2)!=kMuonMinus) {
	fimuon2++;
	if (fimuon2>=fimax2) {fmuon2 = 0; break;}
	fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
    }
}

void AliDimuCombinator::NextPartnerSelected()
{
// Helper for selected dimuon iterator: increment    
    NextPartner();
    while(fmuon2 !=0 && !Selected(fmuon2)) {NextPartner();}
}


TParticle*  AliDimuCombinator::Partner()
{
// Returns current partner for muon to form a dimuon
    return fmuon2;
}

void AliDimuCombinator::FirstMuonPair(TParticle* & muon1, TParticle* & muon2)
{
// Dimuon iterator: initialisation
    FirstMuon();
    FirstPartner();
    muon1=fmuon1;
    muon2=fmuon2;	 
}

void AliDimuCombinator::NextMuonPair(TParticle* & muon1, TParticle* & muon2)
{
// Dimuon iterator: increment    
    NextPartner();
    if (!Partner()) {
	NextMuon();
	FirstPartner();
    }
    muon1=fmuon1;
    muon2=fmuon2;	 
}
void AliDimuCombinator::FirstMuonPairSelected(TParticle* & muon1, 
					      TParticle* & muon2)
{
// Selected dimuon iterator: initialisation    
    FirstMuonSelected();
    FirstPartnerSelected();
    muon1=fmuon1;
    muon2=fmuon2;	 
}

void AliDimuCombinator::NextMuonPairSelected(TParticle* & muon1, 
					     TParticle* & muon2)
{
// Selected dimuon iterator: increment    
    NextPartnerSelected();
    if (!Partner()) {
	NextMuonSelected();
	FirstPartnerSelected();
    }
    muon1=fmuon1;
    muon2=fmuon2;	 
}

void AliDimuCombinator::ResetRange()
{
// Reset index ranges for single muons
    fimin1=fimin2=0;
    fimax1=fimax2=fNParticle;
}

void AliDimuCombinator::SetFirstRange(Int_t from, Int_t to)
{
// Reset index range for first muon
    fimin1=from;
    fimax1=to;
    if (fimax1 > fNParticle) fimax1=fNParticle;
}

void AliDimuCombinator::SetSecondRange(Int_t from, Int_t to)
{
// Reset index range for second muon
    fimin2=from;
    fimax2=to;
    if (fimax2 > fNParticle) fimax2=fNParticle;
}
//
//                       Selection
//

Bool_t AliDimuCombinator::Selected(TParticle* part)
{
// Selection cut for single muon 
//
    if (part==0) {return 0;}
    
    if (part->Pt() > fPtMin && part->Eta()>fEtaMin && part->Eta()<fEtaMax) {
	return 1;
    } else {
	return 0;
    }
}

Bool_t AliDimuCombinator::Selected(TParticle* part1, TParticle* part2)
{
// Selection cut for dimuons
//
     return Selected(part1)*Selected(part2);
}
//
//                       Kinematics
//
Float_t AliDimuCombinator::Mass(TParticle* part1, TParticle* part2)
{
// Invariant mass
//
    Float_t px,py,pz,e;
    px=part1->Px()+part2->Px();
    py=part1->Py()+part2->Py();
    pz=part1->Pz()+part2->Pz();    
    e =part1->Energy()+part2->Energy();
    Float_t p=px*px+py*py+pz*pz;
    if (e*e < p) {
	return -1; 
    } else {
	return TMath::Sqrt(e*e-p);
    }
}

Float_t AliDimuCombinator::PT(TParticle* part1, TParticle* part2)
{
// Transverse momentum of dimuons
//
    Float_t px,py;
    px=part1->Px()+part2->Px();
    py=part1->Py()+part2->Py();
    return TMath::Sqrt(px*px+py*py);
}

Float_t AliDimuCombinator::Pz(TParticle* part1, TParticle* part2)
{
// Pz of dimuon system
//
    return part1->Pz()+part2->Pz();
}

Float_t AliDimuCombinator::Y(TParticle* part1, TParticle* part2)
{
// Rapidity of dimuon system
//
    Float_t pz,e;
    pz=part1->Pz()+part2->Pz();
    e =part1->Energy()+part2->Energy();
    return 0.5*TMath::Log((e+pz)/(e-pz));
}
//                  Response
//
void AliDimuCombinator::SmearGauss(Float_t width, Float_t & value)
{
// Apply gaussian smearing
//
    value+=gRandom->Gaus(0, width);
}
//              Weighting
// 

Float_t AliDimuCombinator::DecayProbability(TParticle* part)
{
// Calculate decay probability for muons from pion and kaon decays
// 
    Float_t d, h, theta, cTau;
    TParticle* parent = Parent(part);
    Int_t ipar=Type(parent);
    if (ipar==kPiPlus || ipar==kPiMinus) {
	cTau=780.4;
    } else if (ipar==kKPlus || ipar==kKMinus) {
	cTau=370.9;
    } else {
	cTau=0;
    }
    
    
    Float_t gammaBeta=(parent->P())/(parent->GetMass());
//
// this part is still very ALICE muon-arm specific
//
    theta=parent->Theta();
    h=90*TMath::Tan(theta);
    
    if (h<4) {
	d=4/TMath::Sin(theta);
    } else {
	d=90/TMath::Cos(theta);
    }
    
    if (cTau > 0) {
	return 1-TMath::Exp(-d/cTau/gammaBeta);
    } else {
	return 1;
    }
}

Float_t AliDimuCombinator::Weight(TParticle* part1, TParticle* part2)
{
// Dimuon weight

    Float_t wgt=(part1->GetWeight())*(part2->GetWeight());
    
    if (Correlated(part1, part2)) {
	return wgt/(Parent(part1)->GetWeight())*fRate1;
    } else {
	return wgt*fRate1*fRate2;
    }
} 


Float_t AliDimuCombinator::Weight(TParticle* part)
{
// Single muon weight
    return (part->GetWeight())*(Parent(part)->GetWeight())*fRate1;
}

Bool_t  AliDimuCombinator::Correlated(TParticle* part1, TParticle* part2)
{
// Check if muons are correlated
//
    if (Origin(part1) == Origin(part2)) {
	return kTRUE;
    } else {
	return kFALSE;
    }
}

TParticle* AliDimuCombinator::Parent(TParticle* part)
{
// Return pointer to parent
//
    return (TParticle*) (fPartArray->UncheckedAt(part->GetFirstMother()));
}

Int_t AliDimuCombinator::Origin(TParticle* part)
{
// Return pointer to primary particle
//
    Int_t iparent= part->GetFirstMother();
    if (iparent < 0) return iparent;
    Int_t ip;
    while(1) {
	ip=((TParticle*) fPartArray->UncheckedAt(iparent))->GetFirstMother();
	if (ip < 0) {
	    break;
	} else {
	    iparent=ip;
	}
    }
    return iparent;
}

AliDimuCombinator& AliDimuCombinator::operator=(const  AliDimuCombinator& rhs)
{
// Assignment operator
    return *this;
}
Commit	Line	Data
4c039060	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/*
	17	$Log$
5c3fd7ea	18	Revision 1.5 2000/06/09 20:35:32 morsch
	19	All coding rule violations except RS3 corrected
	20
f87cfe57	21	Revision 1.4 2000/03/20 18:03:24 morsch
	22	Change muon particle code to PDG code.
	23
127b88a2	24	Revision 1.3 1999/09/29 09:24:08 fca
	25	Introduction of the Copyright and cvs Log
	26
4c039060	27	*/
4c039060	28
fe4da5cc	29	//
	30	//
	31	//
	32	//
dafbc1c5	33	#include "AliDimuCombinator.h"
127b88a2	34	#include "AliPDG.h"
f87cfe57	35	#include <TRandom.h>
f87cfe57	36	#include <TClonesArray.h>
5c3fd7ea	37
fe4da5cc	38	//
dafbc1c5	39	ClassImp(AliDimuCombinator)
f87cfe57	40	AliDimuCombinator::AliDimuCombinator(TClonesArray* Partarray)
	41	{
	42	// Constructor
	43	fPartArray=Partarray;
	44	fNParticle=fPartArray->GetEntriesFast();
	45
	46	fimuon1 =0;
	47	fimuon2 =0;
	48	fmuon1 =0;
	49	fmuon2 =0;
	50	fimin1 = 0;
	51	fimin2 = 0;
	52	fimax1 = fNParticle;
	53	fimax2 = fNParticle;
	54	fPtMin =0;
	55	fEtaMin =-10;
	56	fEtaMax =-10;
	57	fRate1=1.;
	58	fRate2=1.;
	59	}
	60
	61	AliDimuCombinator::AliDimuCombinator(const AliDimuCombinator & combinator)
	62	{
	63	// copy constructor
	64	}
	65
	66
fe4da5cc	67	//
	68	// Iterators
	69	//
f87cfe57	70	TParticle* AliDimuCombinator::FirstMuon()
	71	{
	72	// Single muon iterator: initialisation
	73	fimuon1=fimin1;
	74	fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
	75	while(Type(fmuon1)!=kMuonPlus && Type(fmuon1)!=kMuonMinus) {
	76	fimuon1++;
	77	if (fimuon1 >= fimax1) {fmuon1=0; break;}
	78	fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
	79	}
	80	return fmuon1;
	81	}
	82
	83	TParticle* AliDimuCombinator::FirstMuonSelected()
	84	{
	85	// Single selected muon iterator: initialisation
	86	TParticle * muon=FirstMuon();
	87	while(muon!=0 && !Selected(muon)) {muon=NextMuon();}
	88	return muon;
	89	}
	90
	91
	92	TParticle* AliDimuCombinator::NextMuon()
	93	{
	94	// Single muon iterator: increment
	95	fimuon1++;
	96	if (fimuon1>=fNParticle) {fmuon1 = 0; return fmuon1;}
	97
	98	fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
	99	while(Type(fmuon1)!=kMuonPlus && Type(fmuon1)!=kMuonMinus) {
	100	fimuon1++;
	101	if (fimuon1>=fimax1) {fmuon1 = 0; break;}
	102	fmuon1 = (TParticle*) fPartArray->UncheckedAt(fimuon1);
	103	}
	104	return fmuon1;
	105	}
fe4da5cc	106
1578254f	107	TParticle* AliDimuCombinator::NextMuonSelected()
fe4da5cc	108	{
f87cfe57	109	// Single selected muon iterator: increment
	110	TParticle * muon=NextMuon();
	111	while(muon !=0 && !Selected(muon)) {muon=NextMuon();}
	112	return muon;
fe4da5cc	113	}
	114
	115
f87cfe57	116	void AliDimuCombinator::FirstPartner()
	117	{
	118	// Helper for dimuon iterator: initialisation
	119	if (fimin1==fimin2) {
	120	fimuon2=fimuon1+1;
	121	} else {
	122	fimuon2=fimin2;
	123	}
	124	if (fimuon2 >= fimax2) {fmuon2=0; return;}
	125	fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
	126	while(Type(fmuon2)!=kMuonPlus && Type(fmuon2)!=kMuonMinus) {
	127	fimuon2++;
	128	if (fimuon2 >= fimax2) {fmuon2=0; break;}
	129	fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
	130	}
	131	}
fe4da5cc	132
f87cfe57	133	void AliDimuCombinator::FirstPartnerSelected()
	134	{
	135	// Helper for selected dimuon iterator: initialisation
	136	FirstPartner();
	137	while(fmuon2 !=0 && !Selected(fmuon2)) {NextPartner();}
	138	}
fe4da5cc	139
fe4da5cc	140
f87cfe57	141	void AliDimuCombinator::NextPartner()
	142	{
	143	// Helper for dimuon iterator: increment
	144	fimuon2++;
	145	if (fimuon2>=fimax2) {fmuon2 = 0; return;}
	146
	147
	148	fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
	149
	150	while(Type(fmuon2)!=kMuonPlus && Type(fmuon2)!=kMuonMinus) {
	151	fimuon2++;
	152	if (fimuon2>=fimax2) {fmuon2 = 0; break;}
	153	fmuon2 = (TParticle*) fPartArray->UncheckedAt(fimuon2);
	154	}
	155	}
fe4da5cc	156
dafbc1c5	157	void AliDimuCombinator::NextPartnerSelected()
fe4da5cc	158	{
f87cfe57	159	// Helper for selected dimuon iterator: increment
	160	NextPartner();
	161	while(fmuon2 !=0 && !Selected(fmuon2)) {NextPartner();}
fe4da5cc	162	}
	163
	164
f87cfe57	165	TParticle* AliDimuCombinator::Partner()
	166	{
	167	// Returns current partner for muon to form a dimuon
	168	return fmuon2;
	169	}
fe4da5cc	170
1578254f	171	void AliDimuCombinator::FirstMuonPair(TParticle* & muon1, TParticle* & muon2)
f87cfe57	172	{
	173	// Dimuon iterator: initialisation
	174	FirstMuon();
	175	FirstPartner();
	176	muon1=fmuon1;
	177	muon2=fmuon2;
	178	}
	179
1578254f	180	void AliDimuCombinator::NextMuonPair(TParticle* & muon1, TParticle* & muon2)
f87cfe57	181	{
	182	// Dimuon iterator: increment
	183	NextPartner();
	184	if (!Partner()) {
	185	NextMuon();
	186	FirstPartner();
	187	}
	188	muon1=fmuon1;
	189	muon2=fmuon2;
	190	}
	191	void AliDimuCombinator::FirstMuonPairSelected(TParticle* & muon1,
	192	TParticle* & muon2)
	193	{
	194	// Selected dimuon iterator: initialisation
	195	FirstMuonSelected();
	196	FirstPartnerSelected();
	197	muon1=fmuon1;
	198	muon2=fmuon2;
	199	}
	200
	201	void AliDimuCombinator::NextMuonPairSelected(TParticle* & muon1,
	202	TParticle* & muon2)
	203	{
	204	// Selected dimuon iterator: increment
	205	NextPartnerSelected();
	206	if (!Partner()) {
	207	NextMuonSelected();
	208	FirstPartnerSelected();
	209	}
	210	muon1=fmuon1;
	211	muon2=fmuon2;
	212	}
	213
dafbc1c5	214	void AliDimuCombinator::ResetRange()
fe4da5cc	215	{
f87cfe57	216	// Reset index ranges for single muons
fe4da5cc	217	fimin1=fimin2=0;
	218	fimax1=fimax2=fNParticle;
	219	}
	220
dafbc1c5	221	void AliDimuCombinator::SetFirstRange(Int_t from, Int_t to)
fe4da5cc	222	{
f87cfe57	223	// Reset index range for first muon
fe4da5cc	224	fimin1=from;
	225	fimax1=to;
	226	if (fimax1 > fNParticle) fimax1=fNParticle;
	227	}
	228
dafbc1c5	229	void AliDimuCombinator::SetSecondRange(Int_t from, Int_t to)
fe4da5cc	230	{
f87cfe57	231	// Reset index range for second muon
fe4da5cc	232	fimin2=from;
	233	fimax2=to;
	234	if (fimax2 > fNParticle) fimax2=fNParticle;
	235	}
	236	//
	237	// Selection
	238	//
	239
1578254f	240	Bool_t AliDimuCombinator::Selected(TParticle* part)
fe4da5cc	241	{
f87cfe57	242	// Selection cut for single muon
fe4da5cc	243	//
	244	if (part==0) {return 0;}
	245
1578254f	246	if (part->Pt() > fPtMin && part->Eta()>fEtaMin && part->Eta()<fEtaMax) {
fe4da5cc	247	return 1;
	248	} else {
	249	return 0;
	250	}
fe4da5cc	251	}
fe4da5cc	252
1578254f	253	Bool_t AliDimuCombinator::Selected(TParticle* part1, TParticle* part2)
fe4da5cc	254	{
f87cfe57	255	// Selection cut for dimuons
f87cfe57	256	//
fe4da5cc	257	return Selected(part1)*Selected(part2);
	258	}
	259	//
	260	// Kinematics
	261	//
1578254f	262	Float_t AliDimuCombinator::Mass(TParticle* part1, TParticle* part2)
fe4da5cc	263	{
f87cfe57	264	// Invariant mass
f87cfe57	265	//
fe4da5cc	266	Float_t px,py,pz,e;
1578254f	267	px=part1->Px()+part2->Px();
	268	py=part1->Py()+part2->Py();
	269	pz=part1->Pz()+part2->Pz();
	270	e =part1->Energy()+part2->Energy();
fe4da5cc	271	Float_t p=pxpx+pypy+pz*pz;
	272	if (e*e < p) {
	273	return -1;
	274	} else {
	275	return TMath::Sqrt(e*e-p);
	276	}
	277	}
	278
1578254f	279	Float_t AliDimuCombinator::PT(TParticle* part1, TParticle* part2)
fe4da5cc	280	{
f87cfe57	281	// Transverse momentum of dimuons
f87cfe57	282	//
fe4da5cc	283	Float_t px,py;
1578254f	284	px=part1->Px()+part2->Px();
1578254f	285	py=part1->Py()+part2->Py();
fe4da5cc	286	return TMath::Sqrt(pxpx+pypy);
	287	}
	288
1578254f	289	Float_t AliDimuCombinator::Pz(TParticle* part1, TParticle* part2)
fe4da5cc	290	{
f87cfe57	291	// Pz of dimuon system
f87cfe57	292	//
1578254f	293	return part1->Pz()+part2->Pz();
fe4da5cc	294	}
fe4da5cc	295
1578254f	296	Float_t AliDimuCombinator::Y(TParticle* part1, TParticle* part2)
fe4da5cc	297	{
f87cfe57	298	// Rapidity of dimuon system
f87cfe57	299	//
fe4da5cc	300	Float_t pz,e;
1578254f	301	pz=part1->Pz()+part2->Pz();
1578254f	302	e =part1->Energy()+part2->Energy();
fe4da5cc	303	return 0.5*TMath::Log((e+pz)/(e-pz));
	304	}
	305	// Response
	306	//
dafbc1c5	307	void AliDimuCombinator::SmearGauss(Float_t width, Float_t & value)
fe4da5cc	308	{
f87cfe57	309	// Apply gaussian smearing
f87cfe57	310	//
fe4da5cc	311	value+=gRandom->Gaus(0, width);
	312	}
	313	// Weighting
	314	//
	315
f87cfe57	316	Float_t AliDimuCombinator::DecayProbability(TParticle* part)
fe4da5cc	317	{
f87cfe57	318	// Calculate decay probability for muons from pion and kaon decays
	319	//
	320	Float_t d, h, theta, cTau;
1578254f	321	TParticle* parent = Parent(part);
7d566a7d	322	Int_t ipar=Type(parent);
f87cfe57	323	if (ipar==kPiPlus \|\| ipar==kPiMinus) {
	324	cTau=780.4;
	325	} else if (ipar==kKPlus \|\| ipar==kKMinus) {
	326	cTau=370.9;
7d566a7d	327	} else {
f87cfe57	328	cTau=0;
7d566a7d	329	}
	330
	331
f87cfe57	332	Float_t gammaBeta=(parent->P())/(parent->GetMass());
7d566a7d	333	//
	334	// this part is still very ALICE muon-arm specific
	335	//
1578254f	336	theta=parent->Theta();
7d566a7d	337	h=90*TMath::Tan(theta);
	338
	339	if (h<4) {
	340	d=4/TMath::Sin(theta);
fe4da5cc	341	} else {
7d566a7d	342	d=90/TMath::Cos(theta);
	343	}
	344
f87cfe57	345	if (cTau > 0) {
f87cfe57	346	return 1-TMath::Exp(-d/cTau/gammaBeta);
7d566a7d	347	} else {
7d566a7d	348	return 1;
fe4da5cc	349	}
	350	}
	351
1578254f	352	Float_t AliDimuCombinator::Weight(TParticle* part1, TParticle* part2)
7d566a7d	353	{
f87cfe57	354	// Dimuon weight
f87cfe57	355
1578254f	356	Float_t wgt=(part1->GetWeight())*(part2->GetWeight());
7d566a7d	357
7d566a7d	358	if (Correlated(part1, part2)) {
1578254f	359	return wgt/(Parent(part1)->GetWeight())*fRate1;
7d566a7d	360	} else {
	361	return wgtfRate1fRate2;
	362	}
	363	}
	364
	365
1578254f	366	Float_t AliDimuCombinator::Weight(TParticle* part)
fe4da5cc	367	{
f87cfe57	368	// Single muon weight
1578254f	369	return (part->GetWeight())(Parent(part)->GetWeight())fRate1;
7d566a7d	370	}
f87cfe57	371
1578254f	372	Bool_t AliDimuCombinator::Correlated(TParticle* part1, TParticle* part2)
7d566a7d	373	{
f87cfe57	374	// Check if muons are correlated
f87cfe57	375	//
7d566a7d	376	if (Origin(part1) == Origin(part2)) {
	377	return kTRUE;
	378	} else {
	379	return kFALSE;
	380	}
	381	}
1578254f	382
1578254f	383	TParticle* AliDimuCombinator::Parent(TParticle* part)
7d566a7d	384	{
f87cfe57	385	// Return pointer to parent
f87cfe57	386	//
1578254f	387	return (TParticle*) (fPartArray->UncheckedAt(part->GetFirstMother()));
7d566a7d	388	}
7d566a7d	389
1578254f	390	Int_t AliDimuCombinator::Origin(TParticle* part)
7d566a7d	391	{
f87cfe57	392	// Return pointer to primary particle
f87cfe57	393	//
1578254f	394	Int_t iparent= part->GetFirstMother();
7d566a7d	395	if (iparent < 0) return iparent;
	396	Int_t ip;
	397	while(1) {
1578254f	398	ip=((TParticle*) fPartArray->UncheckedAt(iparent))->GetFirstMother();
7d566a7d	399	if (ip < 0) {
	400	break;
	401	} else {
	402	iparent=ip;
	403	}
	404	}
	405	return iparent;
fe4da5cc	406	}
fe4da5cc	407
f87cfe57	408	AliDimuCombinator& AliDimuCombinator::operator=(const AliDimuCombinator& rhs)
	409	{
	410	// Assignment operator
	411	return *this;
	412	}
	413
	414
	415
	416
	417
	418
	419
	420