#include <G4NuclearAbrasionGeometry.hh>

Collaboration diagram for G4NuclearAbrasionGeometry:

Public Member Functions
	G4NuclearAbrasionGeometry (G4double AP, G4double AT, G4double r)

	~G4NuclearAbrasionGeometry ()

void	SetPeripheralThreshold (G4double)

G4double	GetPeripheralThreshold ()

G4double	F ()

G4double	P ()

G4double	GetExcitationEnergyOfProjectile ()

G4double	GetExcitationEnergyOfTarget ()

Private Attributes
G4double	AP

G4double	AT

G4double	rP

G4double	rT

G4double	r

G4double	n

G4double	b

G4double	m

G4double	Q

G4double	S

G4double	T

G4double	R

G4double	U

G4double	rth

G4double	B

Detailed Description

Definition at line 67 of file G4NuclearAbrasionGeometry.hh.

Constructor & Destructor Documentation

◆ G4NuclearAbrasionGeometry()

G4NuclearAbrasionGeometry::G4NuclearAbrasionGeometry	(	G4double	AP,
		G4double	AT,
		G4double	r
	)

Definition at line 77 of file G4NuclearAbrasionGeometry.cc.

 {
 //
 //
 // Initialise variables for interaction geometry.
 //
   G4WilsonRadius aR;
   AP = AP1;
   AT = AT1;
   rP = aR.GetWilsonRadius(AP);
   rT = aR.GetWilsonRadius(AT);
   r  = r1;
   n  = rP / (rP + rT);
   b  = r / (rP + rT);
   m  = rT / rP;
   Q  = (1.0 - b)/n;
   S  = Q * Q;
   T  = S * Q;
   R  = std::sqrt(m*n);
   U  = 1.0/m - 2.0;
 //
 //
 // Initialise the threshold radius-ratio at which interactions are considered
 // peripheral or central.
 //  
   rth = 2.0/3.0;
   B   = 10.0 * MeV;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~G4NuclearAbrasionGeometry()

G4NuclearAbrasionGeometry::~G4NuclearAbrasionGeometry ( )

Definition at line 108 of file G4NuclearAbrasionGeometry.cc.

109 {;}

Member Function Documentation

◆ F()

G4double G4NuclearAbrasionGeometry::F ( )

Definition at line 151 of file G4NuclearAbrasionGeometry.cc.

 {
 //
 //
 // Initialise the value for F, then determine the actual value depending upon
 // whether the projectile is larger or smaller than the target and these radii
 // in relation to the impact parameter.
 //
   G4double valueF = 0.0;
 
   if (rT > rP)
   {
     if (rT-rP<=r && r<=rT+rP) valueF = 0.75*R*S - 0.125*(3.0*R-1.0)*T;
     else                      valueF = 1.0;
   }
   else
   {
     if (rP-rT<=r && r<=rP+rT) valueF = 0.75*R*S - 0.125*(3.0*std::sqrt(n/m)-
       (1.0-G4Pow::GetInstance()->powA(1.0-m*m,3.0/2.0))*std::sqrt(1.0-G4Pow::GetInstance()->powN(1.0-m,2))/G4Pow::GetInstance()->powN(m,3))*T;
     else                      valueF = (1.0-G4Pow::GetInstance()->powA(1.0-m*m,3.0/2.0))*std::sqrt(1.0-b*b/n/n);
   }
 
   if (!(valueF <= 1.0 && valueF>= 0.0))
   {
     if (valueF > 1.0) valueF = 1.0;
     else         valueF = 0.0;
   }
   return valueF;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetExcitationEnergyOfProjectile()

G4double G4NuclearAbrasionGeometry::GetExcitationEnergyOfProjectile ( )

Definition at line 182 of file G4NuclearAbrasionGeometry.cc.

 {
   G4double F1 = F();
   G4double P1 = P();
   G4double Es = 0.0;
 
   Es = 0.95 * MeV * 4.0 * pi * rP*rP/fermi/fermi *
        (1.0+P1-G4Pow::GetInstance()->A23(1.0-F1));
 //  if (rT < rP && r < rP-rT)
   if ((r-rP)/rT < rth)
   {
     G4double omega = 0.0;
     if      (AP < 12.0)  omega = 1500.0;
     else if (AP <= 16.0) omega = 1500.0 - 320.0*(AP-12.0);
     Es *= 1.0 + F1*(5.0+omega*F1*F1);
   }
   
   if (Es < 0.0) 
     Es = 0.0;
   else if (Es > B * AP)
     Es = B * AP;
   return Es;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetExcitationEnergyOfTarget()

G4double G4NuclearAbrasionGeometry::GetExcitationEnergyOfTarget ( )

Definition at line 207 of file G4NuclearAbrasionGeometry.cc.

 {
   // This member function declares a new G4NuclearAbrasionGeometry object 
   // but with the projectile and target exchanged to determine the values
   // for F and P.  Determination of the excess surface area and excitation
   // energy is as above.
 
   G4NuclearAbrasionGeometry* revAbrasionGeometry =
     new G4NuclearAbrasionGeometry(AT, AP, r);
   G4double F1 = revAbrasionGeometry->F();
   G4double P1 = revAbrasionGeometry->P();
   G4double Es = 0.0;
 
   Es = 0.95 * MeV * 4.0 * pi * rT*rT/fermi/fermi *
        (1.0+P1-G4Pow::GetInstance()->A23(1.0-F1));
 
 //  if (rP < rT && r < rT-rP)
   if ((r-rT)/rP < rth) {
     G4double omega = 0.0;
     if      (AT < 12.0)  omega = 1500.0;
     else if (AT <= 16.0) omega = 1500.0 - 320.0*(AT-12.0);
     Es *= 1.0 + F1*(5.0+omega*F1*F1);
   }
   
   if (Es < 0.0)
     Es = 0.0;
   else if (Es > B * AT)
     Es = B * AT;
 
   delete revAbrasionGeometry;
 
   return Es;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPeripheralThreshold()

G4double G4NuclearAbrasionGeometry::GetPeripheralThreshold ( )

Definition at line 116 of file G4NuclearAbrasionGeometry.cc.

117 {return rth;}

G4NuclearAbrasionGeometry::rth

G4double rth

Definition: G4NuclearAbrasionGeometry.hh:95

◆ P()

G4double G4NuclearAbrasionGeometry::P ( )

Definition at line 120 of file G4NuclearAbrasionGeometry.cc.

 {
 //
 //
 // Initialise the value for P, then determine the actual value depending upon
 // whether the projectile is larger or smaller than the target and these radii
 // in relation to the impact parameter.
 //
   G4double valueP = 0.0;
 
   if (rT > rP)
   {
     if (rT-rP<=r && r<=rT+rP) valueP = 0.125*R*U*S - 0.125*(0.5*R*U+1.0)*T;
     else                      valueP = -1.0;
   }
   else
   {
     if (rP-rT<=r && r<=rP+rT) valueP = 0.125*R*U*S - 0.125*(0.5*std::sqrt(n/m)*U-
       (std::sqrt(1.0-m*m)/n - 1.0)*std::sqrt((2.0-m)/G4Pow::GetInstance()->powN(m,5)))*T;
     else                      valueP = (std::sqrt(1.0-m*m)/n-1.0)*std::sqrt(1.0-b*b/n/n);
   }
 
   if (!(valueP <= 1.0 && valueP>= -1.0))
   {
     if (valueP > 1.0) valueP =  1.0;
     else         valueP = -1.0;
   }
   return valueP;
 }