[u/mrichter/AliRoot.git] / ZDC / AliGenZDC.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.6  2000/11/30 17:16:14  coppedis
Changes suggested by fca

Revision 1.5  2000/11/22 11:30:12  coppedis
Major code revision

Revision 1.4  2000/10/05 08:02:47  fca
Correction of the generator direction

Revision 1.3  2000/10/02 21:28:20  fca
Removal of useless dependecies via forward declarations

Revision 1.2  2000/07/11 11:12:34  fca
Some syntax corrections for non standard HP aCC

Revision 1.1  2000/07/10 13:58:01  fca
New version of ZDC from E.Scomparin & C.Oppedisano

Revision 1.7  2000/01/19 17:17:40  fca

Revision 1.6  1999/09/29 09:24:35  fca
Introduction of the Copyright and cvs Log

*/
#include <assert.h>

#include <TRandom.h>
#include <TLorentzVector.h>
#include <TVector3.h>
#include "TDatabasePDG.h"

#include "AliGenZDC.h"
#include "AliConst.h"
#include "AliPDG.h"
#include "AliRun.h"
#include "AliMCProcess.h"
 
ClassImp(AliGenZDC)
 
//_____________________________________________________________________________
AliGenZDC::AliGenZDC()
   :AliGenerator()
{
  //
  // Default constructor
  //
  fIpart = 0;
}

//_____________________________________________________________________________
AliGenZDC::AliGenZDC(Int_t npart)
   :AliGenerator(npart)
{
  //
  // Standard constructor
  //
  fName = "AliGenZDC";
  fTitle = "Generation of Test Particles for ZDCs";
  fIpart = kNeutron;
  fCosx  = 0.;
  fCosy  = 0.;
  fCosz  = 1.;
  fPseudoRapidity = 0.;
  
  fFermiflag = 1;
  // LHC values for beam divergence and crossing angle
  fBeamDiv = 0.000032;
  fBeamCrossAngle = 0.0001;
  fBeamCrossPlane = 2;
  
  Int_t i, j;
  for(i=0; i<201; i++){
     fProbintp[i] = 0;
     fProbintn[i] = 0;
  }
  for(j=0; j<3; j++){
     fPp[i] = 0;
  }
  fDebugOpt = 0;
}

//_____________________________________________________________________________
void AliGenZDC::Init()
{
  printf("\n\n		AliGenZDC initialized with:\n");
  printf("   Fermi flag = %d, Beam Divergence = %f, Crossing Angle "
         "= %f, Crossing Plane = %d\n\n", fFermiflag, fBeamDiv, fBeamCrossAngle,
	 fBeamCrossPlane);

  //Initialize Fermi momentum distributions for Pb-Pb
  FermiTwoGaussian(207.,82.,fPp,fProbintp,fProbintn);
}  
  
//_____________________________________________________________________________
void AliGenZDC::Generate()
{
  //
  // Generate one trigger (n or p)
  //
  Int_t i;

  Double_t Mass, pLab[3], fP0, fP[3], fBoostP[3], ddp[3], dddp0, dddp[3]; 
  Float_t  fPTrack[3], ptot = fPMin;
  Int_t nt;
  
  if(fPseudoRapidity==0.){ 
    pLab[0] = ptot*fCosx;
    pLab[1] = ptot*fCosy;
    pLab[2] = ptot*fCosz;
  }
  else{
    Float_t scang = 2*TMath::ATan(TMath::Exp(-(fPseudoRapidity)));
    pLab[0] = -ptot*TMath::Sin(scang);
    pLab[1] = 0.;
    pLab[2] = ptot*TMath::Cos(scang);
  }
  for(i=0; i<=2; i++){
     fP[i] = pLab[i];
  }
  
  if(fDebugOpt == 1){
    printf("\n\n		Initial momentum :	\n");
    for(i=0; i<=2; i++){
       printf("	p[%d] = %f\n",i,pLab[i]);
    }
  }
  
  // Beam divergence and crossing angle
  if(fBeamCrossAngle!=0.) {
    BeamDivCross(1,fBeamDiv,fBeamCrossAngle,fBeamCrossPlane,pLab);
    for(i=0; i<=2; i++){
       fP[i] = pLab[i];
    }
  }
  if(fBeamDiv!=0.) {
    BeamDivCross(0,fBeamDiv,fBeamCrossAngle,fBeamCrossPlane,pLab);
    for(i=0; i<=2; i++){
       fP[i] = pLab[i];
    }
  }

  // If required apply the Fermi momentum
  if(fFermiflag==1){
    if((fIpart==kProton) || (fIpart==kNeutron)){
      ExtractFermi(fIpart,fPp,fProbintp,fProbintn,ddp);
    }
    Mass=gAlice->PDGDB()->GetParticle(fIpart)->Mass();
    fP0 = TMath::Sqrt(fP[0]*fP[0]+fP[1]*fP[1]+fP[2]*fP[2]+Mass*Mass);
    for(i=0; i<=2; i++){
       dddp[i] = ddp[i];
    }
    dddp0 = TMath::Sqrt(dddp[0]*dddp[0]+dddp[1]*dddp[1]+dddp[2]*dddp[2]+Mass*Mass);
    
    TVector3 b(fP[0]/fP0, fP[1]/fP0, fP[2]/fP0);
    TLorentzVector pFermi(dddp[0], dddp[1], dddp[2], dddp0);

    
    pFermi.Boost(b);

    for(i=0; i<=2; i++){
       fBoostP[i] = pFermi[i];
       fP[i] = pFermi[i];
    }

  }
  
  for(i=0; i<=2; i++){
     fPTrack[i] = fP[i];
  }
      
  Float_t polar[3] = {0,0,0};
  gAlice->SetTrack(fTrackIt,-1,fIpart,fPTrack,fOrigin.GetArray(),polar,0,
  		   kPPrimary,nt);
  if(fDebugOpt == 1){
    printf("\n\n		Track momentum:\n");
    printf("\n	 fPTrack = %f, %f, %f \n",fPTrack[0],fPTrack[1],fPTrack[2]);
  }
}

//_____________________________________________________________________________
void AliGenZDC::FermiTwoGaussian(Float_t A, Float_t Z, Double_t *fPp, 
                Double_t *fProbintp, Double_t *fProbintn)
{
//
// Momenta distributions according to the "double-gaussian"
// distribution (Ilinov) - equal for protons and neutrons
//

   fProbintp[0] = 0;
   fProbintn[0] = 0;
   Double_t sig1 = 0.113;
   Double_t sig2 = 0.250;
   Double_t alfa = 0.18*(TMath::Power((A/12.),(Float_t)1/3));
   Double_t xk = (2*k2PI)/((1.+alfa)*(TMath::Power(k2PI,1.5)));
   
   for(Int_t i=1; i<=200; i++){
      Double_t p = i*0.005;
      fPp[i] = p;
      Double_t e1 = (p*p)/(2.*sig1*sig1);
      Double_t e2 = (p*p)/(2.*sig2*sig2);
      Double_t f1 = TMath::Exp(-(e1));
      Double_t f2 = TMath::Exp(-(e2));
      Double_t probp = xk*p*p*(f1/(TMath::Power(sig1,3.))+
                      alfa*f2/(TMath::Power(sig2,3.)))*0.005;
      fProbintp[i] = fProbintp[i-1] + probp;
      fProbintn[i] = fProbintp[i];
   }
   if(fDebugOpt == 1){
     printf("\n\n		Initialization of Fermi momenta distribution \n");
     for(Int_t i=0; i<=200; i++){
        printf(" fProbintp[%d] = %f, fProbintn[%d] = %f\n",i,fProbintp[i],i,fProbintn[i]);
     }
   }
} 
//_____________________________________________________________________________
void AliGenZDC::ExtractFermi(Int_t id, Double_t *fPp, Double_t *fProbintp,
                Double_t *fProbintn, Double_t *ddp)
{
//
// Compute Fermi momentum for spectator nucleons
//
  
  Int_t i;
  Float_t xx = gRandom->Rndm();
  assert ( id==kProton || id==kNeutron );
  if(id==kProton){
    for(i=0; i<=200; i++){
       if((xx>=fProbintp[i-1]) && (xx<fProbintp[i])) break;
       }
  }
  else {
    for(i=0; i<=200; i++){
       if((xx>=fProbintn[i-1]) && (xx<fProbintn[i])) break;
       }
   }
         Float_t pext = fPp[i]+0.001;
	 Float_t phi = k2PI*(gRandom->Rndm());
	 Float_t cost = (1.-2.*(gRandom->Rndm()));
	 Float_t tet = TMath::ACos(cost);
	 ddp[0] = pext*TMath::Sin(tet)*TMath::Cos(phi);
	 ddp[1] = pext*TMath::Sin(tet)*TMath::Sin(phi);
	 ddp[2] = pext*cost;

  if(fDebugOpt == 1){
    printf("\n\n		Extraction of Fermi momentum\n");
    printf("\n 	pxFermi = %f  pyFermi = %f  pzFermi = %f \n",ddp[0],ddp[1],ddp[2]); 
  }
}

//_____________________________________________________________________________
void AliGenZDC::BeamDivCross(Int_t icross, Float_t fBeamDiv, Float_t fBeamCrossAngle, 
                Int_t fBeamCrossPlane, Double_t *pLab)
{
  Double_t tetpart, fipart, tetdiv=0, fidiv=0, angleSum[2], tetsum, fisum;
  Double_t rvec;

  Int_t i;
  Double_t pmq = 0.;
  for(i=0; i<=2; i++){
     pmq = pmq+pLab[i]*pLab[i];
  }
  Double_t pmod = TMath::Sqrt(pmq);

  if(icross==0){
    rvec = gRandom->Gaus(0.0,1.0);
    tetdiv = fBeamDiv * TMath::Abs(rvec);
    fidiv = (gRandom->Rndm())*k2PI;
  }
  else if(icross==1){
    if(fBeamCrossPlane==0.){
      tetdiv = 0.;
      fidiv = 0.;
    }
    else if(fBeamCrossPlane==1.){
      tetdiv = fBeamCrossAngle;
      fidiv = 0.;
    }
    else if(fBeamCrossPlane==2.){
      tetdiv = fBeamCrossAngle;
      fidiv = k2PI/4.;
    }
  }

  tetpart = TMath::ATan(TMath::Sqrt(pLab[0]*pLab[0]+pLab[1]*pLab[1])/pLab[2]);
  if(pLab[1]!=0. || pLab[0]!=0.){
    fipart = TMath::ATan2(pLab[1],pLab[0]);
  }
  else{
    fipart = 0.;
  }
  if(fipart<0.) {fipart = fipart+k2PI;}
  tetdiv = tetdiv*kRaddeg;
  fidiv = fidiv*kRaddeg;
  tetpart = tetpart*kRaddeg;
  fipart = fipart*kRaddeg;
  AddAngle(tetpart,fipart,tetdiv,fidiv,angleSum);
  tetsum = angleSum[0];
  fisum  = angleSum[1];
  tetsum = tetsum*kDegrad;
  fisum = fisum*kDegrad;
  pLab[0] = pmod*TMath::Sin(tetsum)*TMath::Cos(fisum);
  pLab[1] = pmod*TMath::Sin(tetsum)*TMath::Sin(fisum);
  pLab[2] = pmod*TMath::Cos(tetsum);
  if(fDebugOpt == 1){
    printf("\n\n		Beam divergence and crossing angle\n");
    for(i=0; i<=2; i++){
       printf(" 	pLab[%d] = %f\n",i,pLab[i]);
    }
  }
}
  
//_____________________________________________________________________________
void  AliGenZDC::AddAngle(Double_t theta1, Double_t phi1, Double_t theta2,
  	       Double_t phi2, Double_t *angleSum)
{
  Double_t temp, conv, cx, cy, cz, ct1, st1, ct2, st2, cp1, sp1, cp2, sp2;
  Double_t rtetsum, tetsum, fisum;
  
  temp = -1.;
  conv = 180./TMath::ACos(temp);
  
  ct1 = TMath::Cos(theta1/conv);
  st1 = TMath::Sin(theta1/conv);
  cp1 = TMath::Cos(phi1/conv);
  sp1 = TMath::Sin(phi1/conv);
  ct2 = TMath::Cos(theta2/conv);
  st2 = TMath::Sin(theta2/conv);
  cp2 = TMath::Cos(phi2/conv);
  sp2 = TMath::Sin(phi2/conv);
  cx = ct1*cp1*st2*cp2+st1*cp1*ct2-sp1*st2*sp2;
  cy = ct1*sp1*st2*cp2+st1*sp1*ct2+cp1*st2*sp2;
  cz = ct1*ct2-st1*st2*cp2;
  
  rtetsum = TMath::ACos(cz);
  tetsum = conv*rtetsum;
  if(tetsum==0. || tetsum==180.){
    fisum = 0.;
    return;
  }
  temp = cx/TMath::Sin(rtetsum);
  if(temp>1.) temp=1.;
  if(temp<-1.) temp=-1.;
  fisum = conv*TMath::ACos(temp);
  if(cy<0) {fisum = 360.-fisum;}
  angleSum[0] = tetsum;
  angleSum[1] = fisum;
}
Commit	Line	Data
68ca986e	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$
5a881c97	18	Revision 1.6 2000/11/30 17:16:14 coppedis
	19	Changes suggested by fca
	20
1de555dc	21	Revision 1.5 2000/11/22 11:30:12 coppedis
	22	Major code revision
	23
866ab5a2	24	Revision 1.4 2000/10/05 08:02:47 fca
	25	Correction of the generator direction
	26
699b37ac	27	Revision 1.3 2000/10/02 21:28:20 fca
	28	Removal of useless dependecies via forward declarations
	29
94de3818	30	Revision 1.2 2000/07/11 11:12:34 fca
	31	Some syntax corrections for non standard HP aCC
	32
c0ceba4c	33	Revision 1.1 2000/07/10 13:58:01 fca
	34	New version of ZDC from E.Scomparin & C.Oppedisano
	35
68ca986e	36	Revision 1.7 2000/01/19 17:17:40 fca
	37
	38	Revision 1.6 1999/09/29 09:24:35 fca
	39	Introduction of the Copyright and cvs Log
	40
	41	*/
94de3818	42	#include <assert.h>
94de3818	43
68ca986e	44	#include <TRandom.h>
	45	#include <TLorentzVector.h>
	46	#include <TVector3.h>
94de3818	47	#include "TDatabasePDG.h"
68ca986e	48
	49	#include "AliGenZDC.h"
	50	#include "AliConst.h"
	51	#include "AliPDG.h"
	52	#include "AliRun.h"
1de555dc	53	#include "AliMCProcess.h"
68ca986e	54
	55	ClassImp(AliGenZDC)
	56
	57	//_____________________________________________________________________________
	58	AliGenZDC::AliGenZDC()
	59	:AliGenerator()
	60	{
	61	//
	62	// Default constructor
	63	//
	64	fIpart = 0;
	65	}
	66
	67	//_____________________________________________________________________________
	68	AliGenZDC::AliGenZDC(Int_t npart)
	69	:AliGenerator(npart)
	70	{
	71	//
	72	// Standard constructor
	73	//
	74	fName = "AliGenZDC";
	75	fTitle = "Generation of Test Particles for ZDCs";
	76	fIpart = kNeutron;
	77	fCosx = 0.;
	78	fCosy = 0.;
	79	fCosz = 1.;
	80	fPseudoRapidity = 0.;
5a881c97	81
68ca986e	82	fFermiflag = 1;
	83	// LHC values for beam divergence and crossing angle
	84	fBeamDiv = 0.000032;
	85	fBeamCrossAngle = 0.0001;
	86	fBeamCrossPlane = 2;
5a881c97	87
	88	Int_t i, j;
	89	for(i=0; i<201; i++){
	90	fProbintp[i] = 0;
	91	fProbintn[i] = 0;
	92	}
	93	for(j=0; j<3; j++){
	94	fPp[i] = 0;
	95	}
	96	fDebugOpt = 0;
68ca986e	97	}
	98
	99	//_____________________________________________________________________________
	100	void AliGenZDC::Init()
	101	{
5a881c97	102	printf("\n\n AliGenZDC initialized with:\n");
866ab5a2	103	printf(" Fermi flag = %d, Beam Divergence = %f, Crossing Angle "
68ca986e	104	"= %f, Crossing Plane = %d\n\n", fFermiflag, fBeamDiv, fBeamCrossAngle,
68ca986e	105	fBeamCrossPlane);
5a881c97	106
68ca986e	107	//Initialize Fermi momentum distributions for Pb-Pb
	108	FermiTwoGaussian(207.,82.,fPp,fProbintp,fProbintn);
	109	}
	110
	111	//_____________________________________________________________________________
	112	void AliGenZDC::Generate()
	113	{
	114	//
	115	// Generate one trigger (n or p)
	116	//
c0ceba4c	117	Int_t i;
c0ceba4c	118
5a881c97	119	Double_t Mass, pLab[3], fP0, fP[3], fBoostP[3], ddp[3], dddp0, dddp[3];
5a881c97	120	Float_t fPTrack[3], ptot = fPMin;
68ca986e	121	Int_t nt;
68ca986e	122
866ab5a2	123	if(fPseudoRapidity==0.){
68ca986e	124	pLab[0] = ptot*fCosx;
	125	pLab[1] = ptot*fCosy;
	126	pLab[2] = ptot*fCosz;
	127	}
	128	else{
	129	Float_t scang = 2*TMath::ATan(TMath::Exp(-(fPseudoRapidity)));
	130	pLab[0] = -ptot*TMath::Sin(scang);
	131	pLab[1] = 0.;
	132	pLab[2] = ptot*TMath::Cos(scang);
	133	}
c0ceba4c	134	for(i=0; i<=2; i++){
68ca986e	135	fP[i] = pLab[i];
	136	}
	137
5a881c97	138	if(fDebugOpt == 1){
	139	printf("\n\n Initial momentum : \n");
	140	for(i=0; i<=2; i++){
	141	printf(" p[%d] = %f\n",i,pLab[i]);
	142	}
	143	}
	144
68ca986e	145	// Beam divergence and crossing angle
866ab5a2	146	if(fBeamCrossAngle!=0.) {
	147	BeamDivCross(1,fBeamDiv,fBeamCrossAngle,fBeamCrossPlane,pLab);
	148	for(i=0; i<=2; i++){
	149	fP[i] = pLab[i];
	150	}
	151	}
	152	if(fBeamDiv!=0.) {
	153	BeamDivCross(0,fBeamDiv,fBeamCrossAngle,fBeamCrossPlane,pLab);
	154	for(i=0; i<=2; i++){
	155	fP[i] = pLab[i];
	156	}
	157	}
	158
68ca986e	159	// If required apply the Fermi momentum
	160	if(fFermiflag==1){
	161	if((fIpart==kProton) \|\| (fIpart==kNeutron)){
	162	ExtractFermi(fIpart,fPp,fProbintp,fProbintn,ddp);
	163	}
5a881c97	164	Mass=gAlice->PDGDB()->GetParticle(fIpart)->Mass();
5a881c97	165	fP0 = TMath::Sqrt(fP[0]fP[0]+fP[1]fP[1]+fP[2]fP[2]+MassMass);
c0ceba4c	166	for(i=0; i<=2; i++){
68ca986e	167	dddp[i] = ddp[i];
68ca986e	168	}
5a881c97	169	dddp0 = TMath::Sqrt(dddp[0]dddp[0]+dddp[1]dddp[1]+dddp[2]dddp[2]+MassMass);
68ca986e	170
866ab5a2	171	TVector3 b(fP[0]/fP0, fP[1]/fP0, fP[2]/fP0);
68ca986e	172	TLorentzVector pFermi(dddp[0], dddp[1], dddp[2], dddp0);
68ca986e	173
68ca986e	174
	175	pFermi.Boost(b);
	176
c0ceba4c	177	for(i=0; i<=2; i++){
68ca986e	178	fBoostP[i] = pFermi[i];
866ab5a2	179	fP[i] = pFermi[i];
68ca986e	180	}
	181
	182	}
866ab5a2	183
	184	for(i=0; i<=2; i++){
	185	fPTrack[i] = fP[i];
	186	}
	187
68ca986e	188	Float_t polar[3] = {0,0,0};
866ab5a2	189	gAlice->SetTrack(fTrackIt,-1,fIpart,fPTrack,fOrigin.GetArray(),polar,0,
1de555dc	190	kPPrimary,nt);
5a881c97	191	if(fDebugOpt == 1){
	192	printf("\n\n Track momentum:\n");
	193	printf("\n fPTrack = %f, %f, %f \n",fPTrack[0],fPTrack[1],fPTrack[2]);
	194	}
68ca986e	195	}
	196
	197	//_____________________________________________________________________________
5a881c97	198	void AliGenZDC::FermiTwoGaussian(Float_t A, Float_t Z, Double_t *fPp,
5a881c97	199	Double_t fProbintp, Double_t fProbintn)
68ca986e	200	{
	201	//
	202	// Momenta distributions according to the "double-gaussian"
	203	// distribution (Ilinov) - equal for protons and neutrons
	204	//
5a881c97	205
68ca986e	206	fProbintp[0] = 0;
	207	fProbintn[0] = 0;
	208	Double_t sig1 = 0.113;
	209	Double_t sig2 = 0.250;
	210	Double_t alfa = 0.18*(TMath::Power((A/12.),(Float_t)1/3));
	211	Double_t xk = (2k2PI)/((1.+alfa)(TMath::Power(k2PI,1.5)));
	212
	213	for(Int_t i=1; i<=200; i++){
	214	Double_t p = i*0.005;
	215	fPp[i] = p;
68ca986e	216	Double_t e1 = (pp)/(2.sig1*sig1);
	217	Double_t e2 = (pp)/(2.sig2*sig2);
	218	Double_t f1 = TMath::Exp(-(e1));
	219	Double_t f2 = TMath::Exp(-(e2));
	220	Double_t probp = xkpp*(f1/(TMath::Power(sig1,3.))+
	221	alfaf2/(TMath::Power(sig2,3.)))0.005;
68ca986e	222	fProbintp[i] = fProbintp[i-1] + probp;
68ca986e	223	fProbintn[i] = fProbintp[i];
5a881c97	224	}
	225	if(fDebugOpt == 1){
	226	printf("\n\n Initialization of Fermi momenta distribution \n");
	227	for(Int_t i=0; i<=200; i++){
	228	printf(" fProbintp[%d] = %f, fProbintn[%d] = %f\n",i,fProbintp[i],i,fProbintn[i]);
	229	}
68ca986e	230	}
	231	}
	232	//_____________________________________________________________________________
5a881c97	233	void AliGenZDC::ExtractFermi(Int_t id, Double_t fPp, Double_t fProbintp,
5a881c97	234	Double_t fProbintn, Double_t ddp)
68ca986e	235	{
	236	//
	237	// Compute Fermi momentum for spectator nucleons
	238	//
5a881c97	239
68ca986e	240	Int_t i;
68ca986e	241	Float_t xx = gRandom->Rndm();
699b37ac	242	assert ( id==kProton \|\| id==kNeutron );
68ca986e	243	if(id==kProton){
	244	for(i=0; i<=200; i++){
	245	if((xx>=fProbintp[i-1]) && (xx<fProbintp[i])) break;
	246	}
	247	}
94de3818	248	else {
68ca986e	249	for(i=0; i<=200; i++){
	250	if((xx>=fProbintn[i-1]) && (xx<fProbintn[i])) break;
	251	}
	252	}
	253	Float_t pext = fPp[i]+0.001;
	254	Float_t phi = k2PI*(gRandom->Rndm());
	255	Float_t cost = (1.-2.*(gRandom->Rndm()));
	256	Float_t tet = TMath::ACos(cost);
	257	ddp[0] = pextTMath::Sin(tet)TMath::Cos(phi);
	258	ddp[1] = pextTMath::Sin(tet)TMath::Sin(phi);
	259	ddp[2] = pext*cost;
5a881c97	260
	261	if(fDebugOpt == 1){
	262	printf("\n\n Extraction of Fermi momentum\n");
	263	printf("\n pxFermi = %f pyFermi = %f pzFermi = %f \n",ddp[0],ddp[1],ddp[2]);
	264	}
68ca986e	265	}
	266
	267	//_____________________________________________________________________________
	268	void AliGenZDC::BeamDivCross(Int_t icross, Float_t fBeamDiv, Float_t fBeamCrossAngle,
5a881c97	269	Int_t fBeamCrossPlane, Double_t *pLab)
68ca986e	270	{
866ab5a2	271	Double_t tetpart, fipart, tetdiv=0, fidiv=0, angleSum[2], tetsum, fisum;
68ca986e	272	Double_t rvec;
c0ceba4c	273
c0ceba4c	274	Int_t i;
68ca986e	275	Double_t pmq = 0.;
c0ceba4c	276	for(i=0; i<=2; i++){
68ca986e	277	pmq = pmq+pLab[i]*pLab[i];
	278	}
	279	Double_t pmod = TMath::Sqrt(pmq);
68ca986e	280
68ca986e	281	if(icross==0){
	282	rvec = gRandom->Gaus(0.0,1.0);
	283	tetdiv = fBeamDiv * TMath::Abs(rvec);
	284	fidiv = (gRandom->Rndm())*k2PI;
	285	}
	286	else if(icross==1){
	287	if(fBeamCrossPlane==0.){
	288	tetdiv = 0.;
	289	fidiv = 0.;
	290	}
	291	else if(fBeamCrossPlane==1.){
	292	tetdiv = fBeamCrossAngle;
	293	fidiv = 0.;
	294	}
	295	else if(fBeamCrossPlane==2.){
	296	tetdiv = fBeamCrossAngle;
	297	fidiv = k2PI/4.;
	298	}
	299	}
866ab5a2	300
	301	tetpart = TMath::ATan(TMath::Sqrt(pLab[0]pLab[0]+pLab[1]pLab[1])/pLab[2]);
	302	if(pLab[1]!=0. \|\| pLab[0]!=0.){
	303	fipart = TMath::ATan2(pLab[1],pLab[0]);
68ca986e	304	}
	305	else{
	306	fipart = 0.;
	307	}
	308	if(fipart<0.) {fipart = fipart+k2PI;}
68ca986e	309	tetdiv = tetdiv*kRaddeg;
	310	fidiv = fidiv*kRaddeg;
	311	tetpart = tetpart*kRaddeg;
	312	fipart = fipart*kRaddeg;
	313	AddAngle(tetpart,fipart,tetdiv,fidiv,angleSum);
	314	tetsum = angleSum[0];
	315	fisum = angleSum[1];
68ca986e	316	tetsum = tetsum*kDegrad;
	317	fisum = fisum*kDegrad;
	318	pLab[0] = pmodTMath::Sin(tetsum)TMath::Cos(fisum);
	319	pLab[1] = pmodTMath::Sin(tetsum)TMath::Sin(fisum);
	320	pLab[2] = pmod*TMath::Cos(tetsum);
5a881c97	321	if(fDebugOpt == 1){
	322	printf("\n\n Beam divergence and crossing angle\n");
	323	for(i=0; i<=2; i++){
	324	printf(" pLab[%d] = %f\n",i,pLab[i]);
	325	}
68ca986e	326	}
	327	}
	328
	329	//_____________________________________________________________________________
	330	void AliGenZDC::AddAngle(Double_t theta1, Double_t phi1, Double_t theta2,
5a881c97	331	Double_t phi2, Double_t *angleSum)
68ca986e	332	{
	333	Double_t temp, conv, cx, cy, cz, ct1, st1, ct2, st2, cp1, sp1, cp2, sp2;
	334	Double_t rtetsum, tetsum, fisum;
	335
	336	temp = -1.;
	337	conv = 180./TMath::ACos(temp);
	338
	339	ct1 = TMath::Cos(theta1/conv);
	340	st1 = TMath::Sin(theta1/conv);
	341	cp1 = TMath::Cos(phi1/conv);
	342	sp1 = TMath::Sin(phi1/conv);
	343	ct2 = TMath::Cos(theta2/conv);
	344	st2 = TMath::Sin(theta2/conv);
	345	cp2 = TMath::Cos(phi2/conv);
	346	sp2 = TMath::Sin(phi2/conv);
	347	cx = ct1cp1st2cp2+st1cp1ct2-sp1st2*sp2;
	348	cy = ct1sp1st2cp2+st1sp1ct2+cp1st2*sp2;
	349	cz = ct1ct2-st1st2*cp2;
	350
	351	rtetsum = TMath::ACos(cz);
	352	tetsum = conv*rtetsum;
	353	if(tetsum==0. \|\| tetsum==180.){
	354	fisum = 0.;
	355	return;
	356	}
	357	temp = cx/TMath::Sin(rtetsum);
	358	if(temp>1.) temp=1.;
	359	if(temp<-1.) temp=-1.;
	360	fisum = conv*TMath::ACos(temp);
	361	if(cy<0) {fisum = 360.-fisum;}
68ca986e	362	angleSum[0] = tetsum;
	363	angleSum[1] = fisum;
	364	}
	365