Changeset 1055 for trunk/source/processes/hadronic/models/coherent_elastic/src

Timestamp:

May 28, 2009, 4:26:57 PM (15 years ago)

Author:

garnier

Message:

maj sur la beta de geant 4.9.3

Location:

trunk/source/processes/hadronic/models/coherent_elastic/src

Files:

• G4ChargeExchange.cc (modified) (2 diffs)
• G4DiffuseElastic.cc (modified) (24 diffs)

trunk/source/processes/hadronic/models/coherent_elastic/src/G4ChargeExchange.cc

@@ -25 +25 @@
 //
 //
-// $Id: G4ChargeExchange.cc,v 1.14 2008/12/18 13:01:48 gunter Exp $
-// GEANT4 tag $Name: geant4-09-02 $
+// $Id: G4ChargeExchange.cc,v 1.13 2008/11/20 12:35:19 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-03-beta-cand-01 $
 //
 //
@@ -312 +312 @@
     dd = 10.;
   }
-  G4double x1 = (1.0 - std::exp(-tmax*bb))*aa/bb;
-  G4double x2 = (1.0 - std::exp(-tmax*dd))*cc/dd;
+  G4double x1 = (1.0 - exp(-tmax*bb))*aa/bb;
+  G4double x2 = (1.0 - exp(-tmax*dd))*cc/dd;
   
   G4double t;

trunk/source/processes/hadronic/models/coherent_elastic/src/G4DiffuseElastic.cc

@@ -24 +24 @@
 // ********************************************************************
 //
-// $Id: G4DiffuseElastic.cc,v 1.20 2008/01/14 10:39:13 vnivanch Exp $
-// GEANT4 tag $Name: geant4-09-02 $
+// $Id: G4DiffuseElastic.cc,v 1.23 2009/03/02 09:17:43 grichine Exp $
+// GEANT4 tag $Name: geant4-09-03-beta-cand-01 $
 //
 //
@@ -67 +67 @@
 {
   SetMinEnergy( 0.01*GeV );
-  SetMaxEnergy( 100.*TeV );
+  SetMaxEnergy( 1.*TeV );
   verboseLevel = 0;
   lowEnergyRecoilLimit = 100.*keV;  
@@ -83 +83 @@
 
   fEnergyBin = 200;
-  fAngleBin = 100;
-
-  fEnergyVector = 0;
+  fAngleBin  = 200;
+
+  fEnergyVector =  new G4PhysicsLogVector( theMinEnergy, theMaxEnergy, fEnergyBin );
   fAngleTable = 0;
 
@@ -107 +107 @@
 {
   SetMinEnergy( 0.01*GeV );
-  SetMaxEnergy( 100.*TeV );
+  SetMaxEnergy( 1.*TeV );
   verboseLevel = 0;
   lowEnergyRecoilLimit = 100.*keV;  
@@ -122 +122 @@
   thePionMinus= G4PionMinus::PionMinus();
 
-  fEnergyBin = 200;
-  fAngleBin = 100;
+  fEnergyBin = 200; // 200; // 100;
+  fAngleBin  = 400; // 200; // 100;
 
   // fEnergyVector = 0;
@@ -174 +174 @@
     fAtomicWeight = (*theElementTable)[jEl]->GetN();     // number of nucleons
     fNuclearRadius = CalculateNuclearRad(fAtomicWeight);
-    if(verboseLevel > 0)    
+
+    if(verboseLevel > 0) 
+    {   
       G4cout<<"G4DiffuseElastic::Initialise() the element: "
             <<(*theElementTable)[jEl]->GetName()<<G4endl;
+    }
     fElementNumberVector.push_back(fAtomicNumber);
     fElementNameVector.push_back((*theElementTable)[jEl]->GetName());
@@ -183 +186 @@
     fAngleBank.push_back(fAngleTable);
   }  
-  return;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// Initialisation for given particle on fly using new element number
-
-void G4DiffuseElastic::InitialiseOnFly(G4double Z, G4double A) 
-{
-  fAtomicNumber = Z;     // atomic number
-  fAtomicWeight = A;     // number of nucleons
-  fNuclearRadius = CalculateNuclearRad(fAtomicWeight);
-  if(verboseLevel > 0)    
-    G4cout<<"G4DiffuseElastic::Initialise() the element with Z = "
-          <<Z<<"; and A = "<<A<<G4endl;
-  fElementNumberVector.push_back(fAtomicNumber);
-
-  BuildAngleTable();
-  fAngleBank.push_back(fAngleTable);
-  return;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Build for given particle and element table of momentum, angle probability.
-// For the moment in lab system. 
-
-void G4DiffuseElastic::BuildAngleTable() 
-{
-  G4int i, j;
-  G4double partMom, kinE, a=0., z = fParticle->GetPDGCharge(), m1 = fParticle->GetPDGMass();
-  G4double theta1, theta2, thetaMax, thetaCoulomb, sum = 0.;
-
-  G4Integrator<G4DiffuseElastic,G4double(G4DiffuseElastic::*)(G4double)> integral;
-  
-  fAngleTable = new G4PhysicsTable(fEnergyBin);
-
-  for(i = 0; i < fEnergyBin; i++)
-  {
-    kinE        = fEnergyVector->GetLowEdgeEnergy(i);
-    partMom     = std::sqrt( kinE*(kinE + 2*m1) );
-    fWaveVector = partMom/hbarc;
-
-    thetaMax    = 10.174/fWaveVector/fNuclearRadius;
-
-    if (thetaMax > pi) thetaMax = pi;
-
-    thetaCoulomb = 0.2*thetaMax;
-
-    if(z)
-    {
-      a = partMom/m1;
-      fBeta          = a/std::sqrt(1+a*a);
-      fZommerfeld    = CalculateZommerfeld( fBeta, z, fAtomicNumber);
-      fAm            = CalculateAm( partMom, fZommerfeld, fAtomicNumber);
-    }
-    G4PhysicsFreeVector* angleVector = new G4PhysicsFreeVector(fAngleBin);
-
-    G4PhysicsLogVector*  angleBins = new G4PhysicsLogVector( 0.01*thetaMax, thetaMax, fAngleBin );
-
-    for(j = 1; j < fAngleBin; j++)
-    {
-      theta1 = angleBins->GetLowEdgeEnergy(j-1);
-      theta2 = angleBins->GetLowEdgeEnergy(j);
-
-      if(theta2 > thetaCoulomb && z) fAddCoulomb = true;
-
-      sum   += integral.Legendre10(this,&G4DiffuseElastic::GetIntegrandFunction, theta1,theta2);
-      
-      angleVector->PutValue( j-1 , theta2, sum );
-      // G4cout<<"j-1 = "<<j-1<<"; theta2 = "<<theta2<<"; sum = "<<sum<<G4endl;
-    }
-    fAddCoulomb = false;
-
-    fAngleTable->insertAt(i,angleVector);
-
-    // delete[] angleVector; 
-    // delete[] angleBins; 
-  }
   return;
 }
@@ -525 +449 @@
   fAtomicWeight  = A;
   fAtomicNumber  = Z;
-  G4double z             = particle->GetPDGCharge();
-  if(z)
+  fNuclearRadius = CalculateNuclearRad(A);
+  fAddCoulomb    = false;
+
+  G4double z     = particle->GetPDGCharge();
+
+  G4double kRt   = fWaveVector*fNuclearRadius*theta;
+  G4double kRtC  = 1.9;
+
+  if( z && (kRt > kRtC) )
   {
     fAddCoulomb = true;
-    fBeta          = CalculateParticleBeta( particle, momentum);
-    fZommerfeld    = CalculateZommerfeld( fBeta, z, fAtomicNumber);
-    fAm            = CalculateAm( momentum, fZommerfeld, fAtomicNumber);
-  }
-  fNuclearRadius = CalculateNuclearRad(A);
-
+    fBeta       = CalculateParticleBeta( particle, momentum);
+    fZommerfeld = CalculateZommerfeld( fBeta, z, fAtomicNumber);
+    fAm         = CalculateAm( momentum, fZommerfeld, fAtomicNumber);
+  }
   G4double sigma = fNuclearRadius*fNuclearRadius*GetDiffElasticSumProb(theta);
 
@@ -552 +481 @@
 {
   G4double m1 = particle->GetPDGMass();
+
   G4LorentzVector lv1(0.,0.,plab,std::sqrt(plab*plab+m1*m1));
 
   G4int iZ = static_cast<G4int>(Z+0.5);
   G4int iA = static_cast<G4int>(A+0.5);
-  G4ParticleDefinition * theDef = 0;
+
+  G4ParticleDefinition* theDef = 0;
 
   if      (iZ == 1 && iA == 1) theDef = theProton;
@@ -575 +506 @@
   G4ThreeVector p1 = lv1.vect();
   G4double ptot    = p1.mag();
-  G4double ptot2 = ptot*ptot;
-  G4double cost = 1 - 0.5*std::fabs(tMand)/ptot2;
+  G4double ptot2   = ptot*ptot;
+  G4double cost    = 1 - 0.5*std::fabs(tMand)/ptot2;
 
   if( cost >= 1.0 )      cost = 1.0;  
@@ -658 +589 @@
   // G4double r0    = 1.08*fermi;
   // G4double rad   = r0*std::pow(A, 1./3.);
+
   G4double kr    = fWaveVector*fNuclearRadius; // wavek*rad;
   G4double kr2   = kr*kr;
@@ -686 +618 @@
   }
   G4double lambda = 15.; // 15 ok
+
   //  G4double kg    = fWaveVector*gamma;   // wavek*delta;
+
   G4double kg    = lambda*(1.-std::exp(-fWaveVector*gamma/lambda));   // wavek*delta;
   G4double kg2   = kg*kg;
+
   // G4double dk2t  = delta*fWaveVector*fWaveVector*theta; // delta*wavek*wavek*theta;
   // G4double dk2t2 = dk2t*dk2t;
   // G4double pikdt = pi*fWaveVector*diffuse*theta;// pi*wavek*diffuse*theta;
+
   G4double pikdt    = lambda*(1.-std::exp(-pi*fWaveVector*diffuse*theta/lambda));   // wavek*delta;
 
@@ -730 +666 @@
   // G4double r0    = 1.08*fermi;
   // G4double rad   = r0*std::pow(A, 1./3.);
+
   G4double kr    = fWaveVector*fNuclearRadius; // wavek*rad;
   G4double kr2   = kr*kr;
@@ -774 +711 @@
 
   G4double kg2   = kg*kg;
+
   // G4double dk2t  = delta*fWaveVector*fWaveVector*theta; // delta*wavek*wavek*theta;
-
   //   G4cout<<"dk2t = "<<dk2t<<G4endl;
-
   // G4double dk2t2 = dk2t*dk2t;
-
   // G4double pikdt = pi*fWaveVector*diffuse*theta;// pi*wavek*diffuse*theta;
+
   G4double pikdt    = lambda*(1.-std::exp(-pi*fWaveVector*diffuse*theta/lambda));   // wavek*delta;
 
@@ -808 +744 @@
 ////////////////////////////////////////////////////////////////////////////
 //
+// return differential elastic probability d(probability)/d(t) with 
+// Coulomb correction
+
+G4double 
+G4DiffuseElastic::GetDiffElasticSumProbA( G4double alpha )
+{
+  G4double theta; 
+
+  theta = std::sqrt(alpha);
+
+  // theta = std::acos( 1 - alpha/2. );
+
+  G4double sigma, bzero, bzero2, bonebyarg, bonebyarg2, damp, damp2;
+  G4double delta, diffuse, gamma;
+  G4double e1, e2, bone, bone2;
+
+  // G4double wavek = momentum/hbarc;  // wave vector
+  // G4double r0    = 1.08*fermi;
+  // G4double rad   = r0*std::pow(A, 1./3.);
+
+  G4double kr    = fWaveVector*fNuclearRadius; // wavek*rad;
+  G4double kr2   = kr*kr;
+  G4double krt   = kr*theta;
+
+  bzero      = BesselJzero(krt);
+  bzero2     = bzero*bzero;    
+  bone       = BesselJone(krt);
+  bone2      = bone*bone;
+  bonebyarg  = BesselOneByArg(krt);
+  bonebyarg2 = bonebyarg*bonebyarg;  
+
+  if (fParticle == theProton)
+  {
+    diffuse = 0.63*fermi;
+    // diffuse = 0.6*fermi;
+    gamma   = 0.3*fermi;
+    delta   = 0.1*fermi*fermi;
+    e1      = 0.3*fermi;
+    e2      = 0.35*fermi;
+  }
+  else // as proton, if were not defined 
+  {
+    diffuse = 0.63*fermi;
+    gamma   = 0.3*fermi;
+    delta   = 0.1*fermi*fermi;
+    e1      = 0.3*fermi;
+    e2      = 0.35*fermi;
+  }
+  G4double lambda = 15.; // 15 ok
+  // G4double kg    = fWaveVector*gamma;   // wavek*delta;
+  G4double kg    = lambda*(1.-std::exp(-fWaveVector*gamma/lambda));   // wavek*delta;
+
+  // G4cout<<"kg = "<<kg<<G4endl;
+
+  if(fAddCoulomb)  // add Coulomb correction
+  {
+    G4double sinHalfTheta  = theta*0.5; // std::sin(0.5*theta);
+    G4double sinHalfTheta2 = sinHalfTheta*sinHalfTheta;
+
+    kg += 0.5*fZommerfeld/kr/(sinHalfTheta2+fAm); // correction at J0()
+  // kg += 0.65*fZommerfeld/kr/(sinHalfTheta2+fAm); // correction at J0()
+  }
+
+  G4double kg2   = kg*kg;
+
+  // G4double dk2t  = delta*fWaveVector*fWaveVector*theta; // delta*wavek*wavek*theta;
+  //   G4cout<<"dk2t = "<<dk2t<<G4endl;
+  // G4double dk2t2 = dk2t*dk2t;
+  // G4double pikdt = pi*fWaveVector*diffuse*theta;// pi*wavek*diffuse*theta;
+
+  G4double pikdt    = lambda*(1.-std::exp(-pi*fWaveVector*diffuse*theta/lambda));   // wavek*delta;
+
+  // G4cout<<"pikdt = "<<pikdt<<G4endl;
+
+  damp           = DampFactor(pikdt);
+  damp2          = damp*damp;
+
+  G4double mode2k2 = (e1*e1+e2*e2)*fWaveVector*fWaveVector;  
+  G4double e2dk3t  = -2.*e2*delta*fWaveVector*fWaveVector*fWaveVector*theta;
+
+  sigma  = kg2;
+  // sigma += dk2t2;
+  sigma *= bzero2;
+  sigma += mode2k2*bone2; 
+  sigma += e2dk3t*bzero*bone;
+
+  // sigma += kr2*(1 + 8.*fZommerfeld*fZommerfeld/kr2)*bonebyarg2;  // correction at J1()/()
+  sigma += kr2*bonebyarg2;  // correction at J1()/()
+
+  sigma *= damp2;          // *rad*rad;
+
+  return sigma;
+}
+
+
+////////////////////////////////////////////////////////////////////////////
+//
 // return differential elastic probability 2*pi*sin(theta)*d(probability)/d(omega) 
 
 G4double 
-G4DiffuseElastic::GetIntegrandFunction( G4double theta )
+G4DiffuseElastic::GetIntegrandFunction( G4double alpha )
 {
   G4double result;
 
-  result  = 2*pi*std::sin(theta);
-  result *= GetDiffElasticSumProb(theta);
+  result  = GetDiffElasticSumProbA(alpha);
+
+  // result *= 2*pi*std::sin(theta);
+
   return result;
 }
@@ -859 +894 @@
 ////////////////////////////////////////////////////////////////////////////
 //
-// Return inv momentum transfer -t > 0 from initialisation table
-
-G4double G4DiffuseElastic::SampleTableT( const G4ParticleDefinition* aParticle, G4double p, 
-                                               G4double Z, G4double A)
-{
-  G4double theta = SampleTableThetaCMS( aParticle,  p, Z, A); // sample theta in cms
-  G4double t     = 2*p*p*( 1 - std::cos(theta) ); // -t !!!
-  return t;
-}
-
-////////////////////////////////////////////////////////////////////////////
-//
 // Return scattering angle sampled in cms
 
@@ -922 +945 @@
 }
 
-////////////////////////////////////////////////////////////////////////////
-//
-// Return scattering angle sampled in cms according to precalculated table.
+/////////////////////////////////////////////////////////////////////////////
+/////////////////////  Table preparation and reading ////////////////////////
+////////////////////////////////////////////////////////////////////////////
+//
+// Return inv momentum transfer -t > 0 from initialisation table
+
+G4double G4DiffuseElastic::SampleTableT( const G4ParticleDefinition* aParticle, G4double p, 
+                                               G4double Z, G4double A)
+{
+  G4double alpha = SampleTableThetaCMS( aParticle,  p, Z, A); // sample theta2 in cms
+  // G4double t     = 2*p*p*( 1 - std::cos(std::sqrt(alpha)) );             // -t !!!
+  G4double t     = p*p*alpha;             // -t !!!
+  return t;
+}
+
+////////////////////////////////////////////////////////////////////////////
+//
+// Return scattering angle2 sampled in cms according to precalculated table.
 
 
@@ -942 +980 @@
   if ( iElement == fElementNumberVector.size() ) 
   {
-    InitialiseOnFly(Z,A);
+    InitialiseOnFly(Z,A); // table preparation, if needed
+
     // iElement--;
 
@@ -955 +994 @@
   G4double kinE = std::sqrt(momentum*momentum + m1*m1) - m1;
 
-  for(iMomentum = 0; iMomentum < fEnergyBin; iMomentum++)
+  for( iMomentum = 0; iMomentum < fEnergyBin; iMomentum++)
   {
     if( kinE < fEnergyVector->GetLowEdgeEnergy(iMomentum) ) break;
   }
-  if ( iMomentum == fEnergyBin ) iMomentum--;   // kinE is more then theMaxEnergy
+  if ( iMomentum >= fEnergyBin ) iMomentum = fEnergyBin-1;   // kinE is more then theMaxEnergy
   if ( iMomentum < 0 )           iMomentum = 0; // against negative index, kinE < theMinEnergy
+
   // G4cout<<"iMomentum = "<<iMomentum<<G4endl;
 
-  if (iMomentum == fEnergyBin -1 || iMomentum == 0 ) // the table edges
+  if (iMomentum == fEnergyBin -1 || iMomentum == 0 )   // the table edges
   {
     position = (*(*fAngleTable)(iMomentum))(fAngleBin-2)*G4UniformRand();
+
     // G4cout<<"position = "<<position<<G4endl;
 
-    for(iAngle = 0; iAngle < fAngleBin; iAngle++)
+    for(iAngle = 0; iAngle < fAngleBin-1; iAngle++)
     {
       if( position < (*(*fAngleTable)(iMomentum))(iAngle) ) break;
     }
-    if (iAngle == fAngleBin) iAngle--;
+    if (iAngle >= fAngleBin-1) iAngle = fAngleBin-2;
+
     // G4cout<<"iAngle = "<<iAngle<<G4endl;
 
     randAngle = GetScatteringAngle(iMomentum, iAngle, position);
+
     // G4cout<<"randAngle = "<<randAngle<<G4endl;
   }
-  else
-  {
-    position = (*(*fAngleTable)(iMomentum))(fAngleBin-2)*G4UniformRand();
+  else  // kinE inside between energy table edges
+  {
+    // position = (*(*fAngleTable)(iMomentum))(fAngleBin-2)*G4UniformRand();
+    position = (*(*fAngleTable)(iMomentum))(0)*G4UniformRand();
+
     // G4cout<<"position = "<<position<<G4endl;
 
-    for(iAngle = 0; iAngle < fAngleBin; iAngle++)
+    for(iAngle = 0; iAngle < fAngleBin-1; iAngle++)
     {
-      if( position < (*(*fAngleTable)(iMomentum))(iAngle) ) break;
+      // if( position < (*(*fAngleTable)(iMomentum))(iAngle) ) break;
+      if( position > (*(*fAngleTable)(iMomentum))(iAngle) ) break;
     }
-    if (iAngle == fAngleBin) iAngle--;
+    if (iAngle >= fAngleBin-1) iAngle = fAngleBin-2;
+
     // G4cout<<"iAngle = "<<iAngle<<G4endl;
 
     theta2  = GetScatteringAngle(iMomentum, iAngle, position);
+
     // G4cout<<"theta2 = "<<theta2<<G4endl;
     E2 = fEnergyVector->GetLowEdgeEnergy(iMomentum);
+
     // G4cout<<"E2 = "<<E2<<G4endl;
-
+    
     iMomentum--;
-
-    position = (*(*fAngleTable)(iMomentum))(fAngleBin-2)*G4UniformRand();
+    
+    // position = (*(*fAngleTable)(iMomentum))(fAngleBin-2)*G4UniformRand();
+
     // G4cout<<"position = "<<position<<G4endl;
 
-    for(iAngle = 0; iAngle < fAngleBin; iAngle++)
+    for(iAngle = 0; iAngle < fAngleBin-1; iAngle++)
     {
-      if( position < (*(*fAngleTable)(iMomentum))(iAngle) ) break;
+      // if( position < (*(*fAngleTable)(iMomentum))(iAngle) ) break;
+      if( position > (*(*fAngleTable)(iMomentum))(iAngle) ) break;
     }
-    if (iAngle == fAngleBin) iAngle--;
-
+    if (iAngle >= fAngleBin-1) iAngle = fAngleBin-2;
+    
     theta1  = GetScatteringAngle(iMomentum, iAngle, position);
+
     // G4cout<<"theta1 = "<<theta1<<G4endl;
+
     E1 = fEnergyVector->GetLowEdgeEnergy(iMomentum);
+
     // G4cout<<"E1 = "<<E1<<G4endl;
 
@@ -1016 +1070 @@
 
     randAngle = W1*theta1 + W2*theta2;
+    
+    // randAngle = theta2;
     // G4cout<<"randAngle = "<<randAngle<<G4endl;
   }
+  // G4double angle = randAngle;
+  // if (randAngle > 0.) randAngle /= 2*pi*std::sin(angle);
+
   return randAngle;
 }
 
+//////////////////////////////////////////////////////////////////////////////
+//
+// Initialisation for given particle on fly using new element number
+
+void G4DiffuseElastic::InitialiseOnFly(G4double Z, G4double A) 
+{
+  fAtomicNumber  = Z;     // atomic number
+  fAtomicWeight  = A;     // number of nucleons
+
+  fNuclearRadius = CalculateNuclearRad(fAtomicWeight);
+  
+  if( verboseLevel > 0 )    
+  {
+    G4cout<<"G4DiffuseElastic::Initialise() the element with Z = "
+          <<Z<<"; and A = "<<A<<G4endl;
+  }
+  fElementNumberVector.push_back(fAtomicNumber);
+
+  BuildAngleTable();
+
+  fAngleBank.push_back(fAngleTable);
+
+  return;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Build for given particle and element table of momentum, angle probability.
+// For the moment in lab system. 
+
+void G4DiffuseElastic::BuildAngleTable() 
+{
+  G4int i, j;
+  G4double partMom, kinE, a = 0., z = fParticle->GetPDGCharge(), m1 = fParticle->GetPDGMass();
+  G4double alpha1, alpha2, alphaMax, alphaCoulomb, delta = 0., sum = 0.;
+
+  G4Integrator<G4DiffuseElastic,G4double(G4DiffuseElastic::*)(G4double)> integral;
+  
+  fAngleTable = new G4PhysicsTable(fEnergyBin);
+
+  for( i = 0; i < fEnergyBin; i++)
+  {
+    kinE        = fEnergyVector->GetLowEdgeEnergy(i);
+    partMom     = std::sqrt( kinE*(kinE + 2*m1) );
+
+    fWaveVector = partMom/hbarc;
+
+    G4double kR     = fWaveVector*fNuclearRadius;
+    G4double kR2    = kR*kR;
+    G4double kRmax  = 18.6; // 10.6; 10.6, 18, 10.174; ~ 3 maxima of J1 or 15., 25.
+    G4double kRcoul = 1.9; // 1.2; 1.4, 2.5; // on the first slope of J1
+    // G4double kRlim  = 1.2;
+    // G4double kRlim2 = kRlim*kRlim/kR2;
+
+    alphaMax = kRmax*kRmax/kR2;
+
+    if (alphaMax > 4.) alphaMax = 4.;  // vmg05-02-09: was pi2 
+
+    alphaCoulomb = kRcoul*kRcoul/kR2;
+
+    if( z )
+    {
+      a           = partMom/m1;         // beta*gamma for m1
+      fBeta       = a/std::sqrt(1+a*a);
+      fZommerfeld = CalculateZommerfeld( fBeta, z, fAtomicNumber);
+      fAm         = CalculateAm( partMom, fZommerfeld, fAtomicNumber);
+    }
+    G4PhysicsFreeVector* angleVector = new G4PhysicsFreeVector(fAngleBin-1);
+
+    // G4PhysicsLogVector*  angleBins = new G4PhysicsLogVector( 0.001*alphaMax, alphaMax, fAngleBin );
+
+    G4double delth = alphaMax/fAngleBin;
+        
+    sum = 0.;
+
+    // fAddCoulomb = false;
+    fAddCoulomb = true;
+
+    // for(j = 1; j < fAngleBin; j++)
+    for(j = fAngleBin-1; j >= 1; j--)
+    {
+      // alpha1 = angleBins->GetLowEdgeEnergy(j-1);
+      // alpha2 = angleBins->GetLowEdgeEnergy(j);
+
+      // alpha1 = alphaMax*(j-1)/fAngleBin;
+      // alpha2 = alphaMax*( j )/fAngleBin;
+
+      alpha1 = delth*(j-1);
+      // if(alpha1 < kRlim2) alpha1 = kRlim2;
+      alpha2 = alpha1 + delth;
+
+      // if( ( alpha2 > alphaCoulomb ) && z ) fAddCoulomb = true;
+      if( ( alpha1 < alphaCoulomb ) && z ) fAddCoulomb = false;
+
+      delta = integral.Legendre10(this, &G4DiffuseElastic::GetIntegrandFunction, alpha1, alpha2);
+      // delta = integral.Legendre96(this, &G4DiffuseElastic::GetIntegrandFunction, alpha1, alpha2);
+
+      sum += delta;
+      
+      angleVector->PutValue( j-1 , alpha1, sum ); // alpha2
+      // G4cout<<"j-1 = "<<j-1<<"; alpha2 = "<<alpha2<<"; sum = "<<sum<<G4endl;
+    }
+    fAngleTable->insertAt(i,angleVector);
+
+    // delete[] angleVector; 
+    // delete[] angleBins; 
+  }
+  return;
+}
+
 /////////////////////////////////////////////////////////////////////////////////
 //
@@ -1026 +1195 @@
 
 G4double 
-G4DiffuseElastic:: GetScatteringAngle(G4int iMomentum, G4int iAngle, G4double position)
+G4DiffuseElastic:: GetScatteringAngle( G4int iMomentum, G4int iAngle, G4double position )
 {
  G4double x1, x2, y1, y2, randAngle;
@@ -1033 +1202 @@
   {
     randAngle = (*fAngleTable)(iMomentum)->GetLowEdgeEnergy(iAngle);
+    // iAngle++;
   }
   else
@@ -1046 +1216 @@
     x2 = (*fAngleTable)(iMomentum)->GetLowEdgeEnergy(iAngle);
 
-    if ( x1 == x2 )    randAngle = x2;
+    if ( x1 == x2 )   randAngle = x2;
     else
     {
-      if ( y1 == y2  ) randAngle = x1 + (x2 - x1)*G4UniformRand();
+      if ( y1 == y2 ) randAngle = x1 + ( x2 - x1 )*G4UniformRand();
       else
       {
-        randAngle = x1 + (position - y1)*(x2 - x1)/(y2 - y1);
+        randAngle = x1 + ( position - y1 )*( x2 - x1 )/( y2 - y1 );
       }
     }
@@ -1270 +1440 @@
 }
 
+///////////////////////////////////////////////////////////////////////////////
+//
+// Test for given particle and element table of momentum, angle probability.
+// For the moment in lab system. 
+
+void G4DiffuseElastic::TestAngleTable(const G4ParticleDefinition* theParticle, G4double partMom,
+                                            G4double Z, G4double A) 
+{
+  fAtomicNumber  = Z;     // atomic number
+  fAtomicWeight  = A;     // number of nucleons
+  fNuclearRadius = CalculateNuclearRad(fAtomicWeight);
+  
+     
+  
+  G4cout<<"G4DiffuseElastic::TestAngleTable() init the element with Z = "
+          <<Z<<"; and A = "<<A<<G4endl;
+ 
+  fElementNumberVector.push_back(fAtomicNumber);
+
+ 
+
+
+  G4int i=0, j;
+  G4double a = 0., z = theParticle->GetPDGCharge(),  m1 = fParticle->GetPDGMass();
+  G4double alpha1=0., alpha2=0., alphaMax=0., alphaCoulomb=0.;
+  G4double deltaL10 = 0., deltaL96 = 0., deltaAG = 0.;
+  G4double sumL10 = 0.,sumL96 = 0.,sumAG = 0.;
+  G4double epsilon = 0.001;
+
+  G4Integrator<G4DiffuseElastic,G4double(G4DiffuseElastic::*)(G4double)> integral;
+  
+  fAngleTable = new G4PhysicsTable(fEnergyBin);
+
+  fWaveVector = partMom/hbarc;
+
+  G4double kR     = fWaveVector*fNuclearRadius;
+  G4double kR2    = kR*kR;
+  G4double kRmax  = 10.6; // 10.6, 18, 10.174; ~ 3 maxima of J1 or 15., 25.
+  G4double kRcoul = 1.2; // 1.4, 2.5; // on the first slope of J1
+
+  alphaMax = kRmax*kRmax/kR2;
+
+  if (alphaMax > 4.) alphaMax = 4.;  // vmg05-02-09: was pi2 
+
+  alphaCoulomb = kRcoul*kRcoul/kR2;
+
+  if( z )
+  {
+      a           = partMom/m1; // beta*gamma for m1
+      fBeta       = a/std::sqrt(1+a*a);
+      fZommerfeld = CalculateZommerfeld( fBeta, z, fAtomicNumber);
+      fAm         = CalculateAm( partMom, fZommerfeld, fAtomicNumber);
+  }
+  G4PhysicsFreeVector* angleVector = new G4PhysicsFreeVector(fAngleBin-1);
+
+  // G4PhysicsLogVector*  angleBins = new G4PhysicsLogVector( 0.001*alphaMax, alphaMax, fAngleBin );
+    
+  
+  fAddCoulomb = false;
+
+  for(j = 1; j < fAngleBin; j++)
+  {
+      // alpha1 = angleBins->GetLowEdgeEnergy(j-1);
+      // alpha2 = angleBins->GetLowEdgeEnergy(j);
+
+    alpha1 = alphaMax*(j-1)/fAngleBin;
+    alpha2 = alphaMax*( j )/fAngleBin;
+
+    if( ( alpha2 > alphaCoulomb ) && z ) fAddCoulomb = true;
+
+    deltaL10 = integral.Legendre10(this, &G4DiffuseElastic::GetIntegrandFunction, alpha1, alpha2);
+    deltaL96 = integral.Legendre96(this, &G4DiffuseElastic::GetIntegrandFunction, alpha1, alpha2);
+    deltaAG  = integral.AdaptiveGauss(this, &G4DiffuseElastic::GetIntegrandFunction, 
+                                       alpha1, alpha2,epsilon);
+
+      // G4cout<<alpha1<<"\t"<<std::sqrt(alpha1)/degree<<"\t"
+      //     <<deltaL10<<"\t"<<deltaL96<<"\t"<<deltaAG<<G4endl;
+
+    sumL10 += deltaL10;
+    sumL96 += deltaL96;
+    sumAG  += deltaAG;
+
+    G4cout<<alpha1<<"\t"<<std::sqrt(alpha1)/degree<<"\t"
+            <<sumL10<<"\t"<<sumL96<<"\t"<<sumAG<<G4endl;
+      
+    angleVector->PutValue( j-1 , alpha1, sumL10 ); // alpha2
+  }
+  fAngleTable->insertAt(i,angleVector);
+  fAngleBank.push_back(fAngleTable);
+
+  /*
+  // Integral over all angle range - Bad accuracy !!!
+
+  sumL10 = integral.Legendre10(this, &G4DiffuseElastic::GetIntegrandFunction, 0., alpha2);
+  sumL96 = integral.Legendre96(this, &G4DiffuseElastic::GetIntegrandFunction, 0., alpha2);
+  sumAG  = integral.AdaptiveGauss(this, &G4DiffuseElastic::GetIntegrandFunction, 
+                                       0., alpha2,epsilon);
+  G4cout<<G4endl;
+  G4cout<<alpha2<<"\t"<<std::sqrt(alpha2)/degree<<"\t"
+            <<sumL10<<"\t"<<sumL96<<"\t"<<sumAG<<G4endl;
+  */
+  return;
+}
+
 //
 //