Index: trunk/source/processes/hadronic/cross_sections/src/G4GGNuclNuclCrossSection.cc
===================================================================
--- trunk/source/processes/hadronic/cross_sections/src/G4GGNuclNuclCrossSection.cc	(revision 1228)
+++ trunk/source/processes/hadronic/cross_sections/src/G4GGNuclNuclCrossSection.cc	(revision 1340)
@@ -33,8 +33,8 @@
 #include "G4IonTable.hh"
 #include "G4ParticleDefinition.hh"
-
-
-
-////////////////////////////////////////////////////////////////////////////////
+#include "G4HadTmpUtil.hh"
+
+
+///////////////////////////////////////////////////////////////////////////////
 //
 //
@@ -49,14 +49,12 @@
 }
 
-///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 //
 //
 
 G4GGNuclNuclCrossSection::~G4GGNuclNuclCrossSection()
-{
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////
+{}
+
+///////////////////////////////////////////////////////////////////////////////
 //
 //
@@ -65,55 +63,63 @@
 G4bool 
 G4GGNuclNuclCrossSection::IsApplicable(const G4DynamicParticle* aDP, 
-					  const G4Element*  anElement)
-{
-  return IsZAApplicable(aDP, anElement->GetZ(), anElement->GetN());
+				       const G4Element*  anElement)
+{
+  G4int Z = G4lrint(anElement->GetZ());
+  G4int N = G4lrint(anElement->GetN());
+  return IsIsoApplicable(aDP, Z, N);
 } 
 
-////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 //
 //
 
 G4bool 
-G4GGNuclNuclCrossSection::IsZAApplicable(const G4DynamicParticle* aDP, 
-					    G4double Z, G4double)
-{
-  G4bool applicable      = false;
-  // G4int baryonNumber     = aDP->GetDefinition()->GetBaryonNumber();
+G4GGNuclNuclCrossSection::IsIsoApplicable(const G4DynamicParticle* aDP, 
+					  G4int Z, G4int)
+{
+  G4bool applicable = false;
   G4double kineticEnergy = aDP->GetKineticEnergy();
 
-  //  const G4ParticleDefinition* theParticle = aDP->GetDefinition();
- 
-  if ( kineticEnergy  >= fLowerLimit && Z > 1.5 ) applicable = true;
-
+  if (kineticEnergy >= fLowerLimit && Z > 1) applicable = true;
   return applicable;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-//
-// Calculates total and inelastic Xsc, derives elastic as total - inelastic accordong to
-// Glauber model with Gribov correction calculated in the dipole approximation on
-// light cone. Gaussian density helps to calculate rest integrals of the model.
-// [1] B.Z. Kopeliovich, nucl-th/0306044 
+///////////////////////////////////////////////////////////////////////////////
+//
+// Calculates total and inelastic Xsc, derives elastic as total - inelastic 
+// accordong to Glauber model with Gribov correction calculated in the dipole 
+// approximation on light cone. Gaussian density helps to calculate rest 
+// integrals of the model. [1] B.Z. Kopeliovich, nucl-th/0306044 
 
 
 G4double G4GGNuclNuclCrossSection::
-GetCrossSection(const G4DynamicParticle* aParticle, const G4Element* anElement, G4double T)
-{
-  return GetIsoZACrossSection(aParticle, anElement->GetZ(), anElement->GetN(), T);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////
-//
-// Calculates total and inelastic Xsc, derives elastic as total - inelastic accordong to
-// Glauber model with Gribov correction calculated in the dipole approximation on
-// light cone. Gaussian density of point-like nucleons helps to calculate rest integrals of the model.
-// [1] B.Z. Kopeliovich, nucl-th/0306044 + simplification above
-
+GetCrossSection(const G4DynamicParticle* aParticle, const G4Element* anElement,
+                G4double T)
+{
+  G4int Z = G4lrint(anElement->GetZ());
+  G4int N = G4lrint(anElement->GetN());
+  return GetZandACrossSection(aParticle, Z, N, T);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Calculates total and inelastic Xsc, derives elastic as total - inelastic 
+// accordong to Glauber model with Gribov correction calculated in the dipole 
+// approximation on light cone. Gaussian density of point-like nucleons helps 
+// to calculate rest integrals of the model. [1] B.Z. Kopeliovich,
+// nucl-th/0306044 + simplification above
 
 
 G4double G4GGNuclNuclCrossSection::
-GetIsoZACrossSection(const G4DynamicParticle* aParticle, G4double tZ, G4double tA, G4double)
-{
-  G4double xsection, sigma, cofInelastic = 2.4, cofTotal = 2.0, nucleusSquare, cB, ratio;
+GetZandACrossSection(const G4DynamicParticle* aParticle,
+                     G4int tZ, G4int tA, G4double)
+{
+  G4double xsection;
+  G4double sigma;
+  G4double cofInelastic = 2.4;
+  G4double cofTotal = 2.0;
+  G4double nucleusSquare;
+  G4double cB;
+  G4double ratio;
 
   G4double pZ = aParticle->GetDefinition()->GetPDGCharge();
@@ -132,8 +138,6 @@
   G4double pR = GetNucleusRadius(pA); 
 
-  cB = GetCoulombBarier(aParticle, tZ, tA, pR, tR);
-
-  if(cB > 0.)
-  {
+  cB = GetCoulombBarier(aParticle, G4double(tZ), G4double(tA), pR, tR);
+  if (cB > 0.) {
 
     sigma = (pZ*tZ+pN*tN)*GetHadronNucleonXscNS(theProton, pTkin, theProton) +
@@ -143,9 +147,6 @@
 
     ratio = sigma/nucleusSquare;
-
     xsection =  nucleusSquare*std::log( 1. + ratio );
-
     fTotalXsc = xsection;
-
     fTotalXsc *= cB;
 
@@ -153,5 +154,4 @@
 
     fInelasticXsc *= cB;
-
     fElasticXsc   = fTotalXsc - fInelasticXsc;
 
@@ -171,5 +171,4 @@
  
     ratio = sigma/nucleusSquare;
-
     fProductionXsc = nucleusSquare*std::log( 1. + cofInelastic*ratio )/cofInelastic;
 
@@ -186,14 +185,14 @@
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 //
 //
 
 G4double G4GGNuclNuclCrossSection::
-GetCoulombBarier(const G4DynamicParticle* aParticle, G4double tZ, G4double tA, G4double pR, G4double tR)
+GetCoulombBarier(const G4DynamicParticle* aParticle, G4double tZ, G4double tA,
+                 G4double pR, G4double tR)
 {
   G4double ratio;
   G4double pZ = aParticle->GetDefinition()->GetPDGCharge();
-
 
   G4double pTkin = aParticle->GetKineticEnergy();
@@ -254,10 +253,6 @@
 
   nucleusSquare = cofTotal*pi*( pR*pR + tR*tR );   // basically 2piRR
-
   ratio = sigma/nucleusSquare;
-
-
-  fInelasticXsc = nucleusSquare*std::log( 1. + cofInelastic*ratio )/cofInelastic;
-   
+  fInelasticXsc = nucleusSquare*std::log(1. + cofInelastic*ratio)/cofInelastic;
   G4double difratio = ratio/(1.+ratio);
 
@@ -272,5 +267,5 @@
 //////////////////////////////////////////////////////////////////////////
 //
-// Return suasi-elastic/inelastic cross-section ratio
+// Return quasi-elastic/inelastic cross-section ratio
 
 G4double G4GGNuclNuclCrossSection::
@@ -298,13 +293,10 @@
 
   nucleusSquare = cofTotal*pi*( pR*pR + tR*tR );   // basically 2piRR
-
   ratio = sigma/nucleusSquare;
-
-  fInelasticXsc = nucleusSquare*std::log( 1. + cofInelastic*ratio )/cofInelastic;
+  fInelasticXsc = nucleusSquare*std::log(1. + cofInelastic*ratio)/cofInelastic;
 
   //  sigma = GetHNinelasticXsc(aParticle, tA, tZ);
   ratio = sigma/nucleusSquare;
-
-  fProductionXsc = nucleusSquare*std::log( 1. + cofInelastic*ratio )/cofInelastic;
+  fProductionXsc = nucleusSquare*std::log(1. + cofInelastic*ratio)/cofInelastic;
 
   if (fInelasticXsc > fProductionXsc) ratio = (fInelasticXsc-fProductionXsc)/fInelasticXsc;
@@ -315,5 +307,5 @@
 }
 
-/////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 //
 // Returns hadron-nucleon Xsc according to differnt parametrisations:
@@ -324,17 +316,15 @@
 G4double 
 G4GGNuclNuclCrossSection::GetHadronNucleonXsc(const G4DynamicParticle* aParticle, 
-                                                  const G4Element* anElement          )
-{
-  G4double At = anElement->GetN();  // number of nucleons 
-  G4double Zt = anElement->GetZ();  // number of protons
-
-
-  return GetHadronNucleonXsc( aParticle, At, Zt );
-}
-
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////
+                                              const G4Element* anElement)
+{
+  G4int At = G4lrint(anElement->GetN());  // number of nucleons 
+  G4int Zt = G4lrint(anElement->GetZ());  // number of protons
+  return GetHadronNucleonXsc(aParticle, At, Zt);
+}
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////
 //
 // Returns hadron-nucleon Xsc according to differnt parametrisations:
@@ -345,15 +335,13 @@
 G4double 
 G4GGNuclNuclCrossSection::GetHadronNucleonXsc(const G4DynamicParticle* aParticle, 
-                                                   G4double At,  G4double Zt       )
+                                                   G4int At, G4int Zt)
 {
   G4double xsection = 0.;
 
-
   G4double targ_mass = G4ParticleTable::GetParticleTable()->
-  GetIonTable()->GetIonMass( G4int(Zt+0.5) , G4int(At+0.5) );
-
+  GetIonTable()->GetIonMass(Zt, At);
   targ_mass = 0.939*GeV;  // ~mean neutron and proton ???
 
-  G4double proj_mass     = aParticle->GetMass();
+  G4double proj_mass = aParticle->GetMass();
   G4double proj_momentum = aParticle->GetMomentum().mag();
   G4double sMand = CalcMandelstamS ( proj_mass , targ_mass , proj_momentum );
@@ -361,17 +349,13 @@
   sMand /= GeV*GeV;  // in GeV for parametrisation
   proj_momentum /= GeV;
-
   const G4ParticleDefinition* pParticle = aParticle->GetDefinition();
-  
 
   if(pParticle == theNeutron) // as proton ??? 
   {
-    xsection = At*(21.70*std::pow(sMand,0.0808) + 56.08*std::pow(sMand,-0.4525));
+    xsection = G4double(At)*(21.70*std::pow(sMand,0.0808) + 56.08*std::pow(sMand,-0.4525));
   } 
   else if(pParticle == theProton) 
   {
-    xsection = At*(21.70*std::pow(sMand,0.0808) + 56.08*std::pow(sMand,-0.4525));
-    // xsection = At*( 49.51*std::pow(sMand,-0.097) + 0.314*std::log(sMand)*std::log(sMand) );
-    // xsection = At*( 38.4 + 0.85*std::abs(std::pow(log(sMand),1.47)) );
+    xsection = G4double(At)*(21.70*std::pow(sMand,0.0808) + 56.08*std::pow(sMand,-0.4525));
   } 
  
@@ -381,5 +365,5 @@
 
 
-/////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 //
 // Returns hadron-nucleon Xsc according to PDG parametrisation (2005):
@@ -388,17 +372,13 @@
 G4double 
 G4GGNuclNuclCrossSection::GetHadronNucleonXscPDG(const G4DynamicParticle* aParticle, 
-                                                  const G4Element* anElement          )
-{
-  G4double At = anElement->GetN();  // number of nucleons 
-  G4double Zt = anElement->GetZ();  // number of protons
-
-
+                                                  const G4Element* anElement)
+{
+  G4int At = G4lrint(anElement->GetN());  // number of nucleons 
+  G4int Zt = G4lrint(anElement->GetZ());  // number of protons
   return GetHadronNucleonXscPDG( aParticle, At, Zt );
 }
 
 
-
-
-/////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 //
 // Returns hadron-nucleon Xsc according to PDG parametrisation (2005):
@@ -408,5 +388,5 @@
 G4double 
 G4GGNuclNuclCrossSection::GetHadronNucleonXscPDG(const G4DynamicParticle* aParticle, 
-                                                     G4double At,  G4double Zt )
+                                                 G4int At, G4int Zt)
 {
   G4double xsection = 0.;
@@ -415,15 +395,11 @@
   if (Nt < 0.) Nt = 0.;  
 
-
   G4double targ_mass = G4ParticleTable::GetParticleTable()->
-  GetIonTable()->GetIonMass( G4int(Zt+0.5) , G4int(At+0.5) );
-
+  GetIonTable()->GetIonMass(Zt, At);
   targ_mass = 0.939*GeV;  // ~mean neutron and proton ???
 
   G4double proj_mass     = aParticle->GetMass(); 
   G4double proj_momentum = aParticle->GetMomentum().mag();
-
   G4double sMand = CalcMandelstamS ( proj_mass , targ_mass , proj_momentum );
-
   sMand         /= GeV*GeV;  // in GeV for parametrisation
 
@@ -435,23 +411,20 @@
   G4double B    = 0.308;
 
-
   const G4ParticleDefinition* pParticle = aParticle->GetDefinition();
   
-
   if(pParticle == theNeutron) // proton-neutron fit 
   {
-    xsection = Zt*( 35.80 + B*std::pow(std::log(sMand/s0),2.) 
-                          + 40.15*std::pow(sMand,-eta1) - 30.*std::pow(sMand,-eta2));
-    xsection  += Nt*( 35.45 + B*std::pow(std::log(sMand/s0),2.) 
-		      + 42.53*std::pow(sMand,-eta1) - 33.34*std::pow(sMand,-eta2)); // pp for nn
+    xsection = G4double(Zt)*( 35.80 + B*std::pow(std::log(sMand/s0),2.) 
+                  + 40.15*std::pow(sMand,-eta1) - 30.*std::pow(sMand,-eta2));
+    xsection += Nt*(35.45 + B*std::pow(std::log(sMand/s0),2.) 
+	     + 42.53*std::pow(sMand,-eta1) - 33.34*std::pow(sMand,-eta2)); // pp for nn
   } 
   else if(pParticle == theProton) 
   {
-      
-      xsection  = Zt*( 35.45 + B*std::pow(std::log(sMand/s0),2.) 
-                          + 42.53*std::pow(sMand,-eta1) - 33.34*std::pow(sMand,-eta2));
-
-      xsection += Nt*( 35.80 + B*std::pow(std::log(sMand/s0),2.) 
-                          + 40.15*std::pow(sMand,-eta1) - 30.*std::pow(sMand,-eta2));
+    xsection = G4double(Zt)*(35.45 + B*std::pow(std::log(sMand/s0),2.) 
+                + 42.53*std::pow(sMand,-eta1) - 33.34*std::pow(sMand,-eta2));
+
+    xsection += Nt*(35.80 + B*std::pow(std::log(sMand/s0),2.) 
+                  + 40.15*std::pow(sMand,-eta1) - 30.*std::pow(sMand,-eta2));
   } 
   xsection *= millibarn; // parametrised in mb
@@ -460,7 +433,5 @@
 
 
-
-
-/////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 //
 // Returns nucleon-nucleon cross-section based on N. Starkov parametrisation of
@@ -469,5 +440,5 @@
 
 G4double 
-G4GGNuclNuclCrossSection::GetHadronNucleonXscNS( G4ParticleDefinition* pParticle, 
+G4GGNuclNuclCrossSection::GetHadronNucleonXscNS(G4ParticleDefinition* pParticle, 
                                                  G4double pTkin, 
                                                  G4ParticleDefinition* tParticle)
@@ -477,7 +448,6 @@
   G4double hnXsc(0);
 
-
-  G4double targ_mass     = tParticle->GetPDGMass();
-  G4double proj_mass     = pParticle->GetPDGMass(); 
+  G4double targ_mass = tParticle->GetPDGMass();
+  G4double proj_mass = pParticle->GetPDGMass(); 
 
   G4double proj_energy   = proj_mass + pTkin; 
@@ -497,8 +467,4 @@
   //  G4double eta2 = 0.458;
   //  G4double B    = 0.308;
-
-  
-
-
   
   if( proj_momentum >= 10. ) // high energy: pp = nn = np
@@ -506,15 +472,13 @@
   {
     Delta = 1.;
-
-    if( proj_energy < 40. ) Delta = 0.916+0.0021*proj_energy;
-
-    if( proj_momentum >= 10.)
-    {
-        B0 = 7.5;
-        A0 = 100. - B0*std::log(3.0e7);
-
-        xsection = A0 + B0*std::log(proj_energy) - 11
-                  + 103*std::pow(2*0.93827*proj_energy + proj_mass*proj_mass+
-                     0.93827*0.93827,-0.165);        //  mb
+    if (proj_energy < 40.) Delta = 0.916+0.0021*proj_energy;
+
+    if (proj_momentum >= 10.) {
+      B0 = 7.5;
+      A0 = 100. - B0*std::log(3.0e7);
+
+      xsection = A0 + B0*std::log(proj_energy) - 11
+                + 103*std::pow(2*0.93827*proj_energy + proj_mass*proj_mass+
+                  0.93827*0.93827,-0.165);        //  mb
     }
   }
@@ -562,51 +526,14 @@
 }
 
-/*
-/////////////////////////////////////////////////////////////////////////////////////
-//
-// Returns hadron-nucleon inelastic cross-section based on proper parametrisation 
-
-G4double 
-G4GGNuclNuclCrossSection::GetHNinelasticXsc(const G4DynamicParticle* aParticle, 
-                                                  const G4Element* anElement          )
-{
-  G4double At = anElement->GetN();  // number of nucleons 
-  G4double Zt = anElement->GetZ();  // number of protons
-
-
-  return GetHNinelasticXsc( aParticle, At, Zt );
-}
-
-/////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////
 //
 // Returns hadron-nucleon inelastic cross-section based on FTF-parametrisation 
 
 G4double 
-G4GGNuclNuclCrossSection::GetHNinelasticXsc(const G4DynamicParticle* aParticle, 
-                                                     G4double At,  G4double Zt )
-{
-  //  G4ParticleDefinition* hadron = aParticle->GetDefinition();
-  G4double sumInelastic, Nt = At - Zt;
-
-  if(Nt < 0.) Nt = 0.;
-  
-  sumInelastic  = Zt*GetHadronNucleonXscNS(aParticle, theProton);
-  sumInelastic += Nt*GetHadronNucleonXscNS(aParticle, theNeutron);    
- 
-  return sumInelastic;
-}
-*/
-
-/////////////////////////////////////////////////////////////////////////////////////
-//
-// Returns hadron-nucleon inelastic cross-section based on FTF-parametrisation 
-
-G4double 
 G4GGNuclNuclCrossSection::GetHNinelasticXscVU(const G4DynamicParticle* aParticle, 
-                                                     G4double At,  G4double Zt )
-{
-  G4int PDGcode    = aParticle->GetDefinition()->GetPDGEncoding();
+                                              G4int At, G4int Zt)
+{
+  G4int PDGcode = aParticle->GetDefinition()->GetPDGEncoding();
   G4int absPDGcode = std::abs(PDGcode);
-
   G4double Elab = aParticle->GetTotalEnergy();              
                           // (s - 2*0.88*GeV*GeV)/(2*0.939*GeV)/GeV;
@@ -650,6 +577,6 @@
                            NumberOfTargetNeutrons * XelPN   );
   }
+
   Xinelastic = Xtotal - Xelastic;
-
   if(Xinelastic < 0.) Xinelastic = 0.;
 
@@ -657,41 +584,20 @@
 }
 
-////////////////////////////////////////////////////////////////////////////////////
-//
-//
-
-G4double 
-G4GGNuclNuclCrossSection::GetNucleusRadius( const G4DynamicParticle* , 
-                                               const G4Element* anElement)
-{
-  G4double At       = anElement->GetN();
+///////////////////////////////////////////////////////////////////////////////
+//
+//
+
+G4double 
+G4GGNuclNuclCrossSection::GetNucleusRadius(const G4DynamicParticle* , 
+                                           const G4Element* anElement)
+{
+  G4double At = anElement->GetN();
   G4double oneThird = 1.0/3.0;
   G4double cubicrAt = std::pow (At, oneThird); 
 
-
   G4double R;  // = fRadiusConst*cubicrAt;
-  /*  
-  G4double tmp = std::pow( cubicrAt-1., 3.);
-  tmp         += At;
-  tmp         *= 0.5;
-
-  if (At > 20.)   // 20.
-  {
-    R = fRadiusConst*std::pow (tmp, oneThird); 
-  }
-  else
-  {
-    R = fRadiusConst*cubicrAt; 
-  }
-  */
-  
   R = fRadiusConst*cubicrAt;
 
-  // return R;  // !!!!
-
-
-  
   G4double meanA  = 21.;
-
   G4double tauA1  = 40.; 
   G4double tauA2  = 10.; 
@@ -715,10 +621,10 @@
   {
     R *= ( 1.0 + b3*( 1. - std::exp( (At - meanA)/tauA3) ) ); 
-  }  
+  }
+
   return R;
- 
-}
-
-////////////////////////////////////////////////////////////////////////////////////
+}
+
+///////////////////////////////////////////////////////////////////////////////
 //
 //
@@ -728,7 +634,4 @@
 {
   G4double R;
-
-  // R = GetNucleusRadiusGG(At);
-
   R = GetNucleusRadiusDE(At);
 
@@ -741,42 +644,23 @@
 G4GGNuclNuclCrossSection::GetNucleusRadiusGG(G4double At)
 {
-  
   G4double oneThird = 1.0/3.0;
   G4double cubicrAt = std::pow (At, oneThird); 
 
-
-  G4double R;  // = fRadiusConst*cubicrAt;
-  
-  /*
-  G4double tmp = std::pow( cubicrAt-1., 3.);
-  tmp         += At;
-  tmp         *= 0.5;
-
-  if (At > 20.)
-  {
-    R = fRadiusConst*std::pow (tmp, oneThird); 
+  G4double R;  // = fRadiusConst*cubicrAt;  
+  R = fRadiusConst*cubicrAt;
+
+  G4double meanA = 20.;
+  G4double tauA  = 20.;
+
+  if ( At > 20.)   // 20.
+  {
+    R *= ( 0.8 + 0.2*std::exp( -(At - meanA)/tauA) ); 
   }
   else
   {
-    R = fRadiusConst*cubicrAt; 
-  }
-  */
-  
-  R = fRadiusConst*cubicrAt;
-
-  G4double meanA = 20.;
-  G4double tauA  = 20.; 
-
-  if ( At > 20.)   // 20.
-  {
-    R *= ( 0.8 + 0.2*std::exp( -(At - meanA)/tauA) ); 
-  }
-  else
-  {
     R *= ( 1.0 + 0.1*( 1. - std::exp( (At - meanA)/tauA) ) ); 
   }
 
   return R;
-
 }
 
@@ -785,5 +669,4 @@
 G4GGNuclNuclCrossSection::GetNucleusRadiusDE(G4double A)
 {
-
   // algorithm from diffuse-elastic
 
@@ -797,5 +680,5 @@
 
 
-  if( A < 50. )
+  if (A < 50.)
   {
     if( 10  < A && A <= 15. )     r0  = a11*( 1 - std::pow(A, -2./3.) )*fermi;   // 1.08*fermi;
@@ -816,11 +699,11 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////
-//
-//
-
-G4double G4GGNuclNuclCrossSection::CalculateEcmValue( const G4double mp , 
-                                                         const G4double mt , 
-                                                         const G4double Plab )
+///////////////////////////////////////////////////////////////////////////////
+//
+//
+
+G4double G4GGNuclNuclCrossSection::CalculateEcmValue(const G4double mp, 
+                                                     const G4double mt, 
+                                                     const G4double Plab)
 {
   G4double Elab = std::sqrt ( mp * mp + Plab * Plab );
@@ -833,11 +716,11 @@
 
 
-////////////////////////////////////////////////////////////////////////////////////
-//
-//
-
-G4double G4GGNuclNuclCrossSection::CalcMandelstamS( const G4double mp , 
-                                                       const G4double mt , 
-                                                       const G4double Plab )
+///////////////////////////////////////////////////////////////////////////////
+//
+//
+
+G4double G4GGNuclNuclCrossSection::CalcMandelstamS(const G4double mp, 
+                                                   const G4double mt, 
+                                                   const G4double Plab)
 {
   G4double Elab = std::sqrt ( mp * mp + Plab * Plab );
@@ -847,6 +730,5 @@
 }
 
-
-//
-//
-///////////////////////////////////////////////////////////////////////////////////////
+//
+//
+///////////////////////////////////////////////////////////////////////////////
