[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.                  *
 **************************************************************************/

/* $Id$ */

//////////////////////////////////////////////////////////////////////
//                                                                  //         //
//      Generator of spectator nucleons (either protons or neutrons)//
//        computes beam crossing and divergence and Fermi momentum  //
//                                                                  //
/////////////////////////////////////////////////////////////////////

#include <assert.h>

#include <TDatabasePDG.h>
#include <TLorentzVector.h>
#include <TMCProcess.h>
#include <TPDGCode.h>
#include <TRandom.h>
#include <TVector3.h>

#include "AliConst.h"
#include "AliGenZDC.h"
#include "AliRun.h"
#include "AliMC.h"
 
ClassImp(AliGenZDC)
 
//_____________________________________________________________________________
AliGenZDC::AliGenZDC()
   :AliGenerator(),
  fIpart(0),
  fCosx(0),  	
  fCosy(0),  	
  fCosz(0),  	
  fPseudoRapidity(0),		
  fFermiflag(0),	
  fBeamDiv(0),	
  fBeamCrossAngle(0),
  fBeamCrossPlane(0),
  fDebugOpt(0)
{
  //
  // Default constructor
  //
}

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

//_____________________________________________________________________________
void AliGenZDC::Init()
{
  //Initialize Fermi momentum distributions for Pb-Pb
  //
  printf("\n\n		AliGenZDC initialization:\n");
  printf("   Particle: %d, Track cosines: x = %f, y = %f, z = %f \n", 
  	 fIpart,fCosx,fCosy,fCosz);
  printf("   Fermi flag = %d, Beam divergence = %f, Crossing angle "
         "= %f, Crossing plane = %d\n\n", fFermiflag, fBeamDiv, fBeamCrossAngle,
	 fBeamCrossPlane);

  FermiTwoGaussian(208.);
}  
  
//_____________________________________________________________________________
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		Particle momentum before divergence and crossing\n");
    for(i=0; i<=2; i++)printf(" 	pLab[%d] = %f\n",i,pLab[i]);
  }
  
  // Beam divergence and crossing angle
  if(fBeamCrossAngle!=0.) {
    BeamDivCross(1, pLab);
    for(i=0; i<=2; i++) fP[i] = pLab[i];
  }
  if(fBeamDiv!=0.) {
    BeamDivCross(0, 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, ddp);
    mass=TDatabasePDG::Instance()->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->GetMCApp()->PushTrack(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]);
  }
  else if(fDebugOpt == 2){
    FILE *file;
    if((file = fopen("SpectMomentum.dat","a")) == NULL){
      printf("Cannot open file  SpectMomentum.dat\n");
      return;
    }
    fprintf(file," %f \t %f \t %f \n",fPTrack[0],fPTrack[1],fPTrack[2]);
    fclose(file);
  }
    
}

//_____________________________________________________________________________
void AliGenZDC::FermiTwoGaussian(Float_t A)
{
//
// Momenta distributions according to the "double-gaussian"
// distribution (Ilinov) - equal for protons and neutrons
//

   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 *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=1; 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, Double_t *pLab)
{
  // Applying beam divergence and crossing angle
  //
  Double_t tetpart, fipart, tetdiv=0, fidiv=0, angleSum[2], tetsum, fisum;
  Double_t rvec;

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

  if(icross==0){      // ##### Beam divergence
    rvec = gRandom->Gaus(0.0,1.0);
    tetdiv = fBeamDiv * TMath::Abs(rvec);
    fidiv = (gRandom->Rndm())*k2PI;
  }
  else if(icross==1){ // ##### Crossing angle
    if(fBeamCrossPlane==0){
      tetdiv = 0.;
      fidiv = 0.;
    }
    else if(fBeamCrossPlane==1){     // Horizontal crossing plane
      tetdiv = fBeamCrossAngle;
      fidiv = 0.;
    }
    else if(fBeamCrossPlane==2){     // Vertical crossing plane
      tetdiv = fBeamCrossAngle;
      fidiv = k2PI/4.;
    }
  }

  tetpart = TMath::ATan2(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){
    if(icross==0) printf("\n\n		Beam divergence \n");
    else  	  printf("\n\n		Beam crossing \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)
{ 
  // Calculating the sum of 2 angles
  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
88cb7938	16	/* $Id$ */
116cbefd	17
8a2624cc	18	//////////////////////////////////////////////////////////////////////
	19	// // //
	20	// Generator of spectator nucleons (either protons or neutrons)//
	21	// computes beam crossing and divergence and Fermi momentum //
	22	// //
	23	/////////////////////////////////////////////////////////////////////
	24
94de3818	25	#include <assert.h>
94de3818	26
116cbefd	27	#include <TDatabasePDG.h>
68ca986e	28	#include <TLorentzVector.h>
116cbefd	29	#include <TMCProcess.h>
	30	#include <TPDGCode.h>
	31	#include <TRandom.h>
68ca986e	32	#include <TVector3.h>
68ca986e	33
68ca986e	34	#include "AliConst.h"
116cbefd	35	#include "AliGenZDC.h"
68ca986e	36	#include "AliRun.h"
5d12ce38	37	#include "AliMC.h"
68ca986e	38
	39	ClassImp(AliGenZDC)
	40
	41	//_____________________________________________________________________________
	42	AliGenZDC::AliGenZDC()
a718c993	43	:AliGenerator(),
	44	fIpart(0),
	45	fCosx(0),
	46	fCosy(0),
	47	fCosz(0),
	48	fPseudoRapidity(0),
	49	fFermiflag(0),
	50	fBeamDiv(0),
	51	fBeamCrossAngle(0),
	52	fBeamCrossPlane(0),
	53	fDebugOpt(0)
68ca986e	54	{
	55	//
	56	// Default constructor
	57	//
68ca986e	58	}
	59
	60	//_____________________________________________________________________________
	61	AliGenZDC::AliGenZDC(Int_t npart)
a718c993	62	:AliGenerator(npart),
	63	fIpart(kNeutron),
	64	fCosx(0.),
	65	fCosy(0.),
	66	fCosz(1.),
	67	fPseudoRapidity(0.),
	68	fFermiflag(1),
	69	fBeamDiv(0.000032),
	70	fBeamCrossAngle(0.0001),
	71	fBeamCrossPlane(2),
	72	fDebugOpt(0)
68ca986e	73	{
	74	//
	75	// Standard constructor
	76	//
	77	fName = "AliGenZDC";
	78	fTitle = "Generation of Test Particles for ZDCs";
5a881c97	79
796c8b58	80	for(Int_t i=0; i<201; i++){
5a881c97	81	fProbintp[i] = 0;
5a881c97	82	fProbintn[i] = 0;
796c8b58	83	fPp[i] = 0;
5a881c97	84	}
68ca986e	85	}
	86
	87	//_____________________________________________________________________________
	88	void AliGenZDC::Init()
	89	{
8a2624cc	90	//Initialize Fermi momentum distributions for Pb-Pb
8a2624cc	91	//
c294be39	92	printf("\n\n AliGenZDC initialization:\n");
	93	printf(" Particle: %d, Track cosines: x = %f, y = %f, z = %f \n",
	94	fIpart,fCosx,fCosy,fCosz);
	95	printf(" Fermi flag = %d, Beam divergence = %f, Crossing angle "
	96	"= %f, Crossing plane = %d\n\n", fFermiflag, fBeamDiv, fBeamCrossAngle,
68ca986e	97	fBeamCrossPlane);
5a881c97	98
fd9afd60	99	FermiTwoGaussian(208.);
68ca986e	100	}
	101
	102	//_____________________________________________________________________________
	103	void AliGenZDC::Generate()
	104	{
	105	//
	106	// Generate one trigger (n or p)
	107	//
c0ceba4c	108	Int_t i;
c0ceba4c	109
8a2624cc	110	Double_t mass, pLab[3], fP0, fP[3], fBoostP[3], ddp[3], dddp0, dddp[3];
5a881c97	111	Float_t fPTrack[3], ptot = fPMin;
68ca986e	112	Int_t nt;
68ca986e	113
866ab5a2	114	if(fPseudoRapidity==0.){
68ca986e	115	pLab[0] = ptot*fCosx;
	116	pLab[1] = ptot*fCosy;
	117	pLab[2] = ptot*fCosz;
	118	}
	119	else{
	120	Float_t scang = 2*TMath::ATan(TMath::Exp(-(fPseudoRapidity)));
	121	pLab[0] = -ptot*TMath::Sin(scang);
	122	pLab[1] = 0.;
	123	pLab[2] = ptot*TMath::Cos(scang);
	124	}
c294be39	125	for(i=0; i<=2; i++) fP[i] = pLab[i];
	126	if(fDebugOpt == 1){
	127	printf("\n\n Particle momentum before divergence and crossing\n");
	128	for(i=0; i<=2; i++)printf(" pLab[%d] = %f\n",i,pLab[i]);
68ca986e	129	}
	130
	131	// Beam divergence and crossing angle
866ab5a2	132	if(fBeamCrossAngle!=0.) {
92339a90	133	BeamDivCross(1, pLab);
c294be39	134	for(i=0; i<=2; i++) fP[i] = pLab[i];
866ab5a2	135	}
866ab5a2	136	if(fBeamDiv!=0.) {
92339a90	137	BeamDivCross(0, pLab);
c294be39	138	for(i=0; i<=2; i++) fP[i] = pLab[i];
866ab5a2	139	}
866ab5a2	140
68ca986e	141	// If required apply the Fermi momentum
68ca986e	142	if(fFermiflag==1){
c294be39	143	if((fIpart==kProton) \|\| (fIpart==kNeutron))
92339a90	144	ExtractFermi(fIpart, ddp);
fc22e8ec	145	mass=TDatabasePDG::Instance()->GetParticle(fIpart)->Mass();
8a2624cc	146	fP0 = TMath::Sqrt(fP[0]fP[0]+fP[1]fP[1]+fP[2]fP[2]+massmass);
c294be39	147	for(i=0; i<=2; i++) dddp[i] = ddp[i];
8a2624cc	148	dddp0 = TMath::Sqrt(dddp[0]dddp[0]+dddp[1]dddp[1]+dddp[2]dddp[2]+massmass);
68ca986e	149
866ab5a2	150	TVector3 b(fP[0]/fP0, fP[1]/fP0, fP[2]/fP0);
68ca986e	151	TLorentzVector pFermi(dddp[0], dddp[1], dddp[2], dddp0);
68ca986e	152
68ca986e	153	pFermi.Boost(b);
c0ceba4c	154	for(i=0; i<=2; i++){
68ca986e	155	fBoostP[i] = pFermi[i];
866ab5a2	156	fP[i] = pFermi[i];
68ca986e	157	}
	158
	159	}
866ab5a2	160
c294be39	161	for(i=0; i<=2; i++) fPTrack[i] = fP[i];
866ab5a2	162
68ca986e	163	Float_t polar[3] = {0,0,0};
5d12ce38	164	gAlice->GetMCApp()->PushTrack(fTrackIt,-1,fIpart,fPTrack,fOrigin.GetArray(),polar,0,
1de555dc	165	kPPrimary,nt);
03cc1ceb	166	// -----------------------------------------------------------------------
5a881c97	167	if(fDebugOpt == 1){
	168	printf("\n\n Track momentum:\n");
	169	printf("\n fPTrack = %f, %f, %f \n",fPTrack[0],fPTrack[1],fPTrack[2]);
	170	}
03cc1ceb	171	else if(fDebugOpt == 2){
	172	FILE *file;
	173	if((file = fopen("SpectMomentum.dat","a")) == NULL){
	174	printf("Cannot open file SpectMomentum.dat\n");
	175	return;
	176	}
	177	fprintf(file," %f \t %f \t %f \n",fPTrack[0],fPTrack[1],fPTrack[2]);
	178	fclose(file);
	179	}
	180
68ca986e	181	}
	182
	183	//_____________________________________________________________________________
92339a90	184	void AliGenZDC::FermiTwoGaussian(Float_t A)
68ca986e	185	{
	186	//
	187	// Momenta distributions according to the "double-gaussian"
	188	// distribution (Ilinov) - equal for protons and neutrons
	189	//
5a881c97	190
68ca986e	191	Double_t sig1 = 0.113;
	192	Double_t sig2 = 0.250;
	193	Double_t alfa = 0.18*(TMath::Power((A/12.),(Float_t)1/3));
	194	Double_t xk = (2k2PI)/((1.+alfa)(TMath::Power(k2PI,1.5)));
	195
	196	for(Int_t i=1; i<=200; i++){
	197	Double_t p = i*0.005;
	198	fPp[i] = p;
68ca986e	199	Double_t e1 = (pp)/(2.sig1*sig1);
	200	Double_t e2 = (pp)/(2.sig2*sig2);
	201	Double_t f1 = TMath::Exp(-(e1));
	202	Double_t f2 = TMath::Exp(-(e2));
	203	Double_t probp = xkpp*(f1/(TMath::Power(sig1,3.))+
	204	alfaf2/(TMath::Power(sig2,3.)))0.005;
68ca986e	205	fProbintp[i] = fProbintp[i-1] + probp;
68ca986e	206	fProbintn[i] = fProbintp[i];
5a881c97	207	}
	208	if(fDebugOpt == 1){
	209	printf("\n\n Initialization of Fermi momenta distribution \n");
c294be39	210	//for(Int_t i=0; i<=200; i++)
c294be39	211	// printf(" fProbintp[%d] = %f, fProbintn[%d] = %f\n",i,fProbintp[i],i,fProbintn[i]);
68ca986e	212	}
	213	}
	214	//_____________________________________________________________________________
92339a90	215	void AliGenZDC::ExtractFermi(Int_t id, Double_t *ddp)
68ca986e	216	{
	217	//
	218	// Compute Fermi momentum for spectator nucleons
	219	//
5a881c97	220
68ca986e	221	Int_t i;
68ca986e	222	Float_t xx = gRandom->Rndm();
699b37ac	223	assert ( id==kProton \|\| id==kNeutron );
68ca986e	224	if(id==kProton){
0ff3ad02	225	for(i=1; i<=200; i++){
68ca986e	226	if((xx>=fProbintp[i-1]) && (xx<fProbintp[i])) break;
	227	}
	228	}
94de3818	229	else {
68ca986e	230	for(i=0; i<=200; i++){
	231	if((xx>=fProbintn[i-1]) && (xx<fProbintn[i])) break;
	232	}
	233	}
	234	Float_t pext = fPp[i]+0.001;
	235	Float_t phi = k2PI*(gRandom->Rndm());
	236	Float_t cost = (1.-2.*(gRandom->Rndm()));
	237	Float_t tet = TMath::ACos(cost);
	238	ddp[0] = pextTMath::Sin(tet)TMath::Cos(phi);
	239	ddp[1] = pextTMath::Sin(tet)TMath::Sin(phi);
	240	ddp[2] = pext*cost;
5a881c97	241
	242	if(fDebugOpt == 1){
	243	printf("\n\n Extraction of Fermi momentum\n");
	244	printf("\n pxFermi = %f pyFermi = %f pzFermi = %f \n",ddp[0],ddp[1],ddp[2]);
	245	}
68ca986e	246	}
	247
	248	//_____________________________________________________________________________
92339a90	249	void AliGenZDC::BeamDivCross(Int_t icross, Double_t *pLab)
68ca986e	250	{
8a2624cc	251	// Applying beam divergence and crossing angle
8a2624cc	252	//
866ab5a2	253	Double_t tetpart, fipart, tetdiv=0, fidiv=0, angleSum[2], tetsum, fisum;
68ca986e	254	Double_t rvec;
c0ceba4c	255
68ca986e	256	Double_t pmq = 0.;
c294be39	257	Int_t i;
c294be39	258	for(i=0; i<=2; i++) pmq = pmq+pLab[i]*pLab[i];
68ca986e	259	Double_t pmod = TMath::Sqrt(pmq);
68ca986e	260
03cc1ceb	261	if(icross==0){ // ##### Beam divergence
68ca986e	262	rvec = gRandom->Gaus(0.0,1.0);
	263	tetdiv = fBeamDiv * TMath::Abs(rvec);
	264	fidiv = (gRandom->Rndm())*k2PI;
	265	}
03cc1ceb	266	else if(icross==1){ // ##### Crossing angle
92339a90	267	if(fBeamCrossPlane==0){
68ca986e	268	tetdiv = 0.;
	269	fidiv = 0.;
	270	}
92339a90	271	else if(fBeamCrossPlane==1){ // Horizontal crossing plane
68ca986e	272	tetdiv = fBeamCrossAngle;
	273	fidiv = 0.;
	274	}
92339a90	275	else if(fBeamCrossPlane==2){ // Vertical crossing plane
68ca986e	276	tetdiv = fBeamCrossAngle;
736c9b58	277	fidiv = k2PI/4.;
68ca986e	278	}
68ca986e	279	}
866ab5a2	280
03cc1ceb	281	tetpart = TMath::ATan2(TMath::Sqrt(pLab[0]pLab[0]+pLab[1]pLab[1]),pLab[2]);
c294be39	282	if(pLab[1]!=0. \|\| pLab[0]!=0.) fipart = TMath::ATan2(pLab[1],pLab[0]);
c294be39	283	else fipart = 0.;
68ca986e	284	if(fipart<0.) {fipart = fipart+k2PI;}
68ca986e	285	tetdiv = tetdiv*kRaddeg;
	286	fidiv = fidiv*kRaddeg;
	287	tetpart = tetpart*kRaddeg;
	288	fipart = fipart*kRaddeg;
	289	AddAngle(tetpart,fipart,tetdiv,fidiv,angleSum);
	290	tetsum = angleSum[0];
	291	fisum = angleSum[1];
68ca986e	292	tetsum = tetsum*kDegrad;
	293	fisum = fisum*kDegrad;
	294	pLab[0] = pmodTMath::Sin(tetsum)TMath::Cos(fisum);
	295	pLab[1] = pmodTMath::Sin(tetsum)TMath::Sin(fisum);
03cc1ceb	296	pLab[2] = pmod*TMath::Cos(tetsum);
5a881c97	297	if(fDebugOpt == 1){
03cc1ceb	298	if(icross==0) printf("\n\n Beam divergence \n");
03cc1ceb	299	else printf("\n\n Beam crossing \n");
c294be39	300	for(i=0; i<=2; i++)printf(" pLab[%d] = %f\n",i,pLab[i]);
68ca986e	301	}
	302	}
	303
	304	//_____________________________________________________________________________
	305	void AliGenZDC::AddAngle(Double_t theta1, Double_t phi1, Double_t theta2,
5a881c97	306	Double_t phi2, Double_t *angleSum)
8a2624cc	307	{
8a2624cc	308	// Calculating the sum of 2 angles
68ca986e	309	Double_t temp, conv, cx, cy, cz, ct1, st1, ct2, st2, cp1, sp1, cp2, sp2;
	310	Double_t rtetsum, tetsum, fisum;
	311
	312	temp = -1.;
	313	conv = 180./TMath::ACos(temp);
	314
	315	ct1 = TMath::Cos(theta1/conv);
	316	st1 = TMath::Sin(theta1/conv);
	317	cp1 = TMath::Cos(phi1/conv);
	318	sp1 = TMath::Sin(phi1/conv);
	319	ct2 = TMath::Cos(theta2/conv);
	320	st2 = TMath::Sin(theta2/conv);
	321	cp2 = TMath::Cos(phi2/conv);
	322	sp2 = TMath::Sin(phi2/conv);
	323	cx = ct1cp1st2cp2+st1cp1ct2-sp1st2*sp2;
	324	cy = ct1sp1st2cp2+st1sp1ct2+cp1st2*sp2;
	325	cz = ct1ct2-st1st2*cp2;
	326
	327	rtetsum = TMath::ACos(cz);
	328	tetsum = conv*rtetsum;
	329	if(tetsum==0. \|\| tetsum==180.){
	330	fisum = 0.;
	331	return;
	332	}
	333	temp = cx/TMath::Sin(rtetsum);
	334	if(temp>1.) temp=1.;
	335	if(temp<-1.) temp=-1.;
	336	fisum = conv*TMath::ACos(temp);
	337	if(cy<0) {fisum = 360.-fisum;}
68ca986e	338	angleSum[0] = tetsum;
	339	angleSum[1] = fisum;
	340	}
	341