From: enrico Date: Thu, 11 Dec 2003 09:16:01 +0000 (+0000) Subject: ..to comply with coding conventions.. X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=commitdiff_plain;h=86d81a3c879ce9a16fcbfdf55b80002b568868ee;ds=sidebyside ..to comply with coding conventions.. --- diff --git a/ZDC/AliZDCFragment.cxx b/ZDC/AliZDCFragment.cxx index 05e6c668fb3..08c585c4fa7 100644 --- a/ZDC/AliZDCFragment.cxx +++ b/ZDC/AliZDCFragment.cxx @@ -67,33 +67,33 @@ void AliZDCFragment::GenerateIMF(Int_t* fZZ, Int_t &fNalpha) Int_t i,j; // Coefficients of polynomial for average number of IMF - const Float_t ParamNimf[5]={0.011236,1.8364,56.572,-116.24,58.289}; + const Float_t kParamNimf[5]={0.011236,1.8364,56.572,-116.24,58.289}; // Coefficients of polynomial for fluctuations on average number of IMF - const Float_t ParamFluctNimf[4]={-0.13176,2.9392,-5.2147,2.3092}; + const Float_t kParamFluctNimf[4]={-0.13176,2.9392,-5.2147,2.3092}; // Coefficients of polynomial for average maximum Z of fragments - const Float_t ParamZmax[4]={0.16899,14.203,-2.8284,65.036}; + const Float_t kParamZmax[4]={0.16899,14.203,-2.8284,65.036}; // Coefficients of polynomial for fluctuations on maximum Z of fragments - const Float_t ParamFluctZmax[5]={0.013782,-0.17282,1.5065,1.0654,-2.4317}; + const Float_t kParamFluctZmax[5]={0.013782,-0.17282,1.5065,1.0654,-2.4317}; // Coefficients of polynomial for exponent tau of fragments Z distribution - const Float_t ParamTau[3]={6.7233,-15.85,13.047}; + const Float_t kParamTau[3]={6.7233,-15.85,13.047}; //Coefficients of polynomial for average number of alphas - const Float_t ParamNalpha[4]={-0.68554,39.605,-68.311,30.165}; + const Float_t kParamNalpha[4]={-0.68554,39.605,-68.311,30.165}; // Coefficients of polynomial for fluctuations on average number of alphas - const Float_t ParamFluctNalpha[5]={0.283,6.2141,-17.113,17.394,-6.6084}; + const Float_t kParamFluctNalpha[5]={0.283,6.2141,-17.113,17.394,-6.6084}; // Coefficients of function for Pb nucleus skin - const Float_t ParamSkinPb[2]={0.93,11.05}; + const Float_t kParamSkinPb[2]={0.93,11.05}; // Thickness of nuclear surface - const Float_t NuclearThick = 0.52; + const Float_t kNuclearThick = 0.52; // Maximum impact parameter for U [r0*A**(1/3)] - const Float_t bMaxU = 14.87; + const Float_t kbMaxU = 14.87; // Maximum impact parameter for Pb [r0*A**(1/3)] - const Float_t bMaxPb = 14.22; + const Float_t kbMaxPb = 14.22; // Z of the projectile - const Float_t ZProj = 82.; + const Float_t kZProj = 82.; // From b(Pb) to b(U) - Float_t bU = fB*bMaxU/bMaxPb; + Float_t bU = fB*kbMaxU/kbMaxPb; // From b(U) to Zbound(U) // --- A.Schuttauf et al, Nuc.Phys. A607 (1996) 457 --------------- @@ -101,53 +101,53 @@ void AliZDCFragment::GenerateIMF(Int_t* fZZ, Int_t &fNalpha) // which is approx. constant, the constant value is found // integrating the nucleus cross surface from 0 to bmax=R1+R2 where // R = 1.2*A**(1/3). This value has been measured in Aladin (U+U). - Float_t ZbU = bU*bU*TMath::Pi()/7.48; + Float_t zbU = bU*bU*TMath::Pi()/7.48; // Rescale Zbound for Pb - fZbAverage = ZProj/92.*ZbU; + fZbAverage = kZProj/92.*zbU; - // Zbound is proportional to b**2 up to b < bMaxPb-2*NuclearThick + // Zbound is proportional to b**2 up to b < kbMaxPb-2*kNuclearThick // and then it is an increasing exponential, imposing that at - // b=bMaxPb-2NuclearThick the two functions have the same derivative - Float_t bCore = bMaxPb-2*NuclearThick; + // b=kbMaxPb-2kNuclearThick the two functions have the same derivative + Float_t bCore = kbMaxPb-2*kNuclearThick; if(fB>bCore){ - fZbAverage=ZProj*(1.-TMath::Exp(-ParamSkinPb[0]*(fB-ParamSkinPb[1]))); + fZbAverage=kZProj*(1.-TMath::Exp(-kParamSkinPb[0]*(fB-kParamSkinPb[1]))); } - if(fZbAverage>ZProj) fZbAverage = ZProj; - Float_t ZbNorm = fZbAverage/ZProj; - Float_t bNorm = fB/bMaxPb; + if(fZbAverage>kZProj) fZbAverage = kZProj; + Float_t zbNorm = fZbAverage/kZProj; + Float_t bNorm = fB/kbMaxPb; // From Zbound to ,,tau // Polinomial fits to Aladin distribution // --- A.Schuttauf et al, Nuc.Phys. A607 (1996) 457. - Float_t AverageNimf = ParamNimf[0]+ParamNimf[1]*ZbNorm+ParamNimf[2]* - TMath::Power(ZbNorm,2)+ParamNimf[3]*TMath::Power(ZbNorm,3)+ - ParamNimf[4]*TMath::Power(ZbNorm,4); + Float_t averageNimf = kParamNimf[0]+kParamNimf[1]*zbNorm+kParamNimf[2]* + TMath::Power(zbNorm,2)+kParamNimf[3]*TMath::Power(zbNorm,3)+ + kParamNimf[4]*TMath::Power(zbNorm,4); // Add fluctuation: from Singh et al. - Float_t FluctNimf = ParamFluctNimf[0]+ParamFluctNimf[1]*ZbNorm+ - ParamFluctNimf[2]*TMath::Power(ZbNorm,2)+ParamFluctNimf[3] - *TMath::Power(ZbNorm,3); + Float_t fluctNimf = kParamFluctNimf[0]+kParamFluctNimf[1]*zbNorm+ + kParamFluctNimf[2]*TMath::Power(zbNorm,2)+kParamFluctNimf[3] + *TMath::Power(zbNorm,3); Float_t xx = gRandom->Gaus(0.0,1.0); - FluctNimf = FluctNimf*xx; - fNimf = Int_t(AverageNimf+FluctNimf); + fluctNimf = fluctNimf*xx; + fNimf = Int_t(averageNimf+fluctNimf); Float_t y = gRandom->Rndm(); - if(y < ((AverageNimf+FluctNimf)-fNimf)) fNimf += 1; - if(fNimf ==0 && ZbNorm>0.75) fNimf = 1; + if(y < ((averageNimf+fluctNimf)-fNimf)) fNimf += 1; + if(fNimf ==0 && zbNorm>0.75) fNimf = 1; - Float_t AverageZmax = ParamZmax[0]+ParamZmax[1]*ZbNorm+ParamZmax[2]* - TMath::Power(ZbNorm,2)+ParamZmax[3]*TMath::Power(ZbNorm,3); - fTau = ParamTau[0]+ParamTau[1]*ZbNorm+ParamTau[2]*TMath::Power(ZbNorm,2); + Float_t averageZmax = kParamZmax[0]+kParamZmax[1]*zbNorm+kParamZmax[2]* + TMath::Power(zbNorm,2)+kParamZmax[3]*TMath::Power(zbNorm,3); + fTau = kParamTau[0]+kParamTau[1]*zbNorm+kParamTau[2]*TMath::Power(zbNorm,2); // Add fluctuation to mean value of Zmax (see Hubele) - Float_t FluctZmax = ParamFluctZmax[0]+ParamFluctZmax[1]*ZbNorm+ - ParamFluctZmax[2]*TMath::Power(ZbNorm,2)+ParamFluctZmax[3]* - TMath::Power(ZbNorm,3)+ParamFluctZmax[4]*TMath::Power(ZbNorm,4); - FluctZmax = FluctZmax*ZProj/6.; + Float_t fluctZmax = kParamFluctZmax[0]+kParamFluctZmax[1]*zbNorm+ + kParamFluctZmax[2]*TMath::Power(zbNorm,2)+kParamFluctZmax[3]* + TMath::Power(zbNorm,3)+kParamFluctZmax[4]*TMath::Power(zbNorm,4); + fluctZmax = fluctZmax*kZProj/6.; Float_t xg = gRandom->Gaus(0.0,1.0); - FluctZmax = FluctZmax*xg; - fZmax = AverageZmax+FluctZmax; - if(fZmax>ZProj) fZmax = ZProj; + fluctZmax = fluctZmax*xg; + fZmax = averageZmax+fluctZmax; + if(fZmax>kZProj) fZmax = kZProj; // printf("\n\n ------------------------------------------------------------"); // printf("\n Generation of nuclear fragments\n"); @@ -156,44 +156,44 @@ void AliZDCFragment::GenerateIMF(Int_t* fZZ, Int_t &fNalpha) // Find the number of alpha particles // from Singh et al. : Pb+emulsion - Float_t AverageAlpha = ParamNalpha[0]+ParamNalpha[1]*ZbNorm+ - ParamNalpha[2]*TMath::Power(ZbNorm,2)+ParamNalpha[3]* - TMath::Power(ZbNorm,3); - Float_t FluctAlpha = ParamFluctNalpha[0]+ParamFluctNalpha[1]* - ZbNorm+ParamFluctNalpha[2]*TMath::Power(ZbNorm,2)+ - ParamFluctNalpha[3]*TMath::Power(ZbNorm,3)+ - ParamFluctNalpha[4]*TMath::Power(ZbNorm,4); + Float_t averageAlpha = kParamNalpha[0]+kParamNalpha[1]*zbNorm+ + kParamNalpha[2]*TMath::Power(zbNorm,2)+kParamNalpha[3]* + TMath::Power(zbNorm,3); + Float_t fluctAlpha = kParamFluctNalpha[0]+kParamFluctNalpha[1]* + zbNorm+kParamFluctNalpha[2]*TMath::Power(zbNorm,2)+ + kParamFluctNalpha[3]*TMath::Power(zbNorm,3)+ + kParamFluctNalpha[4]*TMath::Power(zbNorm,4); Float_t xxx = gRandom->Gaus(0.0,1.0); - FluctAlpha = FluctAlpha*xxx; - fNalpha = Int_t(AverageAlpha+FluctAlpha); + fluctAlpha = fluctAlpha*xxx; + fNalpha = Int_t(averageAlpha+fluctAlpha); Float_t yy = gRandom->Rndm(); - if(yy < ((AverageAlpha+FluctAlpha)-fNalpha)) fNalpha += 1; + if(yy < ((averageAlpha+fluctAlpha)-fNalpha)) fNalpha += 1; // 2 possibilities: // 1) for bNorm < 0.9 ==> first remove alphas, then fragments // 2) for bNorm > 0.9 ==> first remove fragments, then alphas - Int_t Choice = 0; - Float_t ZbFrag = 0, SumZ = 0.; + Int_t choice = 0; + Float_t zbFrag = 0, sumZ = 0.; if(bNorm<=0.9) { // remove alpha from zbound to find zbound for fragments (Z>=3) - ZbFrag = fZbAverage-fNalpha*2; - Choice = 1; + zbFrag = fZbAverage-fNalpha*2; + choice = 1; } else { - ZbFrag = fZbAverage; - Choice = 0; + zbFrag = fZbAverage; + choice = 0; } -// printf("\n Choice = %d, fZbAverage = %f, ZbFrag = %f \n", Choice, fZbAverage, ZbFrag); +// printf("\n choice = %d, fZbAverage = %f, zbFrag = %f \n", choice, fZbAverage, zbFrag); - // Check if ZbFrag < fZmax - if(ZbFrag<=fZmax) { - if(fNimf>0 && ZbFrag>=2){ + // Check if zbFrag < fZmax + if(zbFrag<=fZmax) { + if(fNimf>0 && zbFrag>=2){ fNimf = 1; - fZZ[0] = Int_t(ZbFrag); - SumZ = ZbFrag; + fZZ[0] = Int_t(zbFrag); + sumZ = zbFrag; } else { fNimf = 0; @@ -246,23 +246,23 @@ void AliZDCFragment::GenerateIMF(Int_t* fZZ, Int_t &fNalpha) // Check that the sum of the bound charges is not > than Zbound-Zalfa for(Int_t ii=0; iiZbFrag){ + if(sumZ>zbFrag){ for(i=0; i< fNimf; i++){ k += 1; - SumZ -= fZZ[i]; - if(SumZ<=ZbFrag){ + sumZ -= fZZ[i]; + if(sumZ<=zbFrag){ fNimf -= (i+1); break; } } } else { - if(Choice == 1) return; - Int_t iDiff = Int_t((ZbFrag-SumZ)/2); + if(choice == 1) return; + Int_t iDiff = Int_t((zbFrag-sumZ)/2); if(iDiff