Geant4: G4RegularXTRadiator Class Reference

G4RegularXTRadiator::G4RegularXTRadiator	(	G4LogicalVolume *	anEnvelope,
		G4Material *	,
		G4Material *	,
		G4double	,
		G4double	,
		G4int	,
		const G4String &	processName = `"XTRegularRadiator"`
	)

Definition at line 42 of file G4RegularXTRadiator.cc.

References G4VXTRenergyLoss::fAlphaGas, G4VXTRenergyLoss::fAlphaPlate, G4cout, and G4endl.

00045                                                                       :
00046   G4VXTRenergyLoss(anEnvelope,foilMat,gasMat,a,b,n,processName)
00047 {
00048   G4cout<<"Regular X-ray TR  radiator EM process is called"<<G4endl ;
00049 
00050   // Build energy and angular integral spectra of X-ray TR photons from
00051   // a radiator
00052 
00053   fAlphaPlate = 10000;
00054   fAlphaGas   = 1000;
00055   G4cout<<"fAlphaPlate = "<<fAlphaPlate<<" ; fAlphaGas = "<<fAlphaGas<<G4endl ;
00056 
00057   // BuildTable() ;
00058 }

G4RegularXTRadiator::~G4RegularXTRadiator ( )

Definition at line 62 of file G4RegularXTRadiator.cc.

00063 {
00064   ;
00065 }

G4double G4RegularXTRadiator::GetStackFactor	(	G4double	energy,
		G4double	gamma,
		G4double	varAngle
	)			`[virtual]`

Reimplemented from G4VXTRenergyLoss.

Definition at line 171 of file G4RegularXTRadiator.cc.

References G4VXTRenergyLoss::fAlphaGas, G4VXTRenergyLoss::fAlphaPlate, G4VXTRenergyLoss::fGasThick, G4VXTRenergyLoss::fPlateNumber, G4VXTRenergyLoss::fPlateThick, G4VXTRenergyLoss::GetGasFormationZone(), G4VXTRenergyLoss::GetGasLinearPhotoAbs(), G4VXTRenergyLoss::GetPlateFormationZone(), G4VXTRenergyLoss::GetPlateLinearPhotoAbs(), and G4VXTRenergyLoss::OneInterfaceXTRdEdx().

00173 {
00174 
00175   // some gamma (10000/1000) like algorithm
00176 
00177   G4double result, Za, Zb, Ma, Mb;
00178   
00179   Za = GetPlateFormationZone(energy,gamma,varAngle);
00180   Zb = GetGasFormationZone(energy,gamma,varAngle);
00181 
00182   Ma = GetPlateLinearPhotoAbs(energy);
00183   Mb = GetGasLinearPhotoAbs(energy);
00184 
00185 
00186   G4complex Ca(1.0+0.5*fPlateThick*Ma/fAlphaPlate,fPlateThick/Za/fAlphaPlate); 
00187   G4complex Cb(1.0+0.5*fGasThick*Mb/fAlphaGas,fGasThick/Zb/fAlphaGas); 
00188 
00189   G4complex Ha = std::pow(Ca,-fAlphaPlate);  
00190   G4complex Hb = std::pow(Cb,-fAlphaGas);
00191   G4complex H  = Ha*Hb;
00192   
00193   G4complex F1 =   (1.0 - Ha)*(1.0 - Hb )/(1.0 - H)
00194                  * G4double(fPlateNumber);
00195 
00196   G4complex F2 =   (1.0-Ha)*(1.0-Ha)*Hb/(1.0-H)/(1.0-H)
00197                  * (1.0 - std::pow(H,fPlateNumber));
00198 
00199   G4complex R  = (F1 + F2)*OneInterfaceXTRdEdx(energy,gamma,varAngle);
00200   
00201   result       = 2.0*std::real(R);
00202   
00203   return      result;
00204   
00205   /*
00206    // numerically stable but slow algorithm
00207 
00208   G4double result, Qa, Qb, Q, aZa, bZb, aMa, bMb;   // , D; 
00209  
00210   aZa = fPlateThick/GetPlateFormationZone(energy,gamma,varAngle);
00211   bZb = fGasThick/GetGasFormationZone(energy,gamma,varAngle);
00212   aMa = fPlateThick*GetPlateLinearPhotoAbs(energy);
00213   bMb = fGasThick*GetGasLinearPhotoAbs(energy);
00214   Qa = std::exp(-aMa);
00215   Qb = std::exp(-bMb);
00216   Q  = Qa*Qb;
00217   G4complex Ha( std::exp(-0.5*aMa)*std::cos(aZa),
00218                -std::exp(-0.5*aMa)*std::sin(aZa)   );  
00219   G4complex Hb( std::exp(-0.5*bMb)*std::cos(bZb),
00220                -std::exp(-0.5*bMb)*std::sin(bZb)    );
00221   G4complex H  = Ha*Hb;
00222   
00223   G4complex Hs = conj(H);
00224   D            = 1.0 /( (1 - std::sqrt(Q))*(1 - std::sqrt(Q)) + 
00225                   4*std::sqrt(Q)*std::sin(0.5*(aZa+bZb))*std::sin(0.5*(aZa+bZb)) );
00226   G4complex F1 = (1.0 - Ha)*(1.0 - Hb)*(1.0 - Hs)
00227                  * G4double(fPlateNumber)*D;
00228   G4complex F2 = (1.0-Ha)*(1.0-Ha)*Hb*(1.0-Hs)*(1.0-Hs)
00229                  * (1.0 - std::pow(H,fPlateNumber)) * D*D;
00230   G4complex R  = (F1 + F2)*OneInterfaceXTRdEdx(energy,gamma,varAngle);
00231   
00232 
00233   G4complex S(0.,0.), c(1.,0.);
00234   G4int k;
00235   for(k = 1; k < fPlateNumber; k++)
00236   {
00237     c *= H;
00238     S += ( G4double(fPlateNumber) - G4double(k) )*c; 
00239   }
00240   G4complex R  = (2.- Ha - 1./Ha)*S + (1. - Ha)*G4double(fPlateNumber);
00241             R *= OneInterfaceXTRdEdx(energy,gamma,varAngle);
00242   result       = 2.0*std::real(R); 
00243   return      result;
00244   */
00245 }

G4double G4RegularXTRadiator::SpectralXTRdEdx ( G4double energy ) [virtual]

Reimplemented from G4VXTRenergyLoss.

Definition at line 71 of file G4RegularXTRadiator.cc.

References G4VXTRenergyLoss::fGamma, G4VXTRenergyLoss::fGasThick, G4VXTRenergyLoss::fPlateNumber, G4VXTRenergyLoss::fPlateThick, G4VXTRenergyLoss::fSigma1, G4VXTRenergyLoss::fSigma2, G4cout, G4endl, G4VXTRenergyLoss::GetGasLinearPhotoAbs(), G4VXTRenergyLoss::GetPlateLinearPhotoAbs(), G4INCL::Math::pi, and G4VProcess::verboseLevel.

00072 {
00073   G4double result, sum = 0., tmp, cof1, cof2, cofMin, cofPHC, theta2, theta2k; 
00074     G4double aMa, bMb ,sigma, dump;
00075   G4int k, kMax, kMin;
00076 
00077   aMa = fPlateThick*GetPlateLinearPhotoAbs(energy);
00078   bMb = fGasThick*GetGasLinearPhotoAbs(energy);
00079   sigma = 0.5*(aMa + bMb);
00080   dump = std::exp(-fPlateNumber*sigma);
00081   if(verboseLevel > 2)  G4cout<<" dump = "<<dump<<G4endl;  
00082   cofPHC  = 4*pi*hbarc;
00083   tmp     = (fSigma1 - fSigma2)/cofPHC/energy;  
00084   cof1    = fPlateThick*tmp;
00085   cof2    = fGasThick*tmp;
00086 
00087   cofMin  =  energy*(fPlateThick + fGasThick)/fGamma/fGamma;
00088   cofMin += (fPlateThick*fSigma1 + fGasThick*fSigma2)/energy;
00089   cofMin /= cofPHC;
00090 
00091   theta2 = cofPHC/(energy*(fPlateThick + fGasThick));
00092 
00093   //  if (fGamma < 1200) kMin = G4int(cofMin);  // 1200 ?
00094   // else               kMin = 1;
00095 
00096 
00097   kMin = G4int(cofMin);
00098   if (cofMin > kMin) kMin++;
00099 
00100   // tmp  = (fPlateThick + fGasThick)*energy*fMaxThetaTR;
00101   // tmp /= cofPHC;
00102   // kMax = G4int(tmp);
00103   // if(kMax < 0) kMax = 0;
00104   // kMax += kMin;
00105   
00106 
00107   kMax = kMin + 49; //  19; // kMin + G4int(tmp);
00108 
00109   // tmp /= fGamma;
00110   // if( G4int(tmp) < kMin ) kMin = G4int(tmp);
00111 
00112   if(verboseLevel > 2)
00113   {    
00114     G4cout<<cof1<<"     "<<cof2<<"        "<<cofMin<<G4endl;
00115     G4cout<<"kMin = "<<kMin<<";    kMax = "<<kMax<<G4endl;
00116   }
00117   for( k = kMin; k <= kMax; k++ )
00118   {
00119     tmp    = pi*fPlateThick*(k + cof2)/(fPlateThick + fGasThick);
00120     result = (k - cof1)*(k - cof1)*(k + cof2)*(k + cof2);
00121     // tmp = std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
00122     if( k == kMin && kMin == G4int(cofMin) )
00123     {
00124       sum   += 0.5*std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
00125     }
00126     else
00127     {
00128       sum   += std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
00129     }
00130     theta2k = std::sqrt(theta2*std::abs(k-cofMin));
00131 
00132     if(verboseLevel > 2)
00133     {    
00134       // G4cout<<"k = "<<k<<"; sqrt(theta2k) = "<<theta2k<<"; tmp = "<<std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result
00135       //     <<";    sum = "<<sum<<G4endl;  
00136       G4cout<<k<<"   "<<theta2k<<"     "<<std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result
00137               <<"      "<<sum<<G4endl;  
00138     }  
00139   }
00140   result = 2*( cof1 + cof2 )*( cof1 + cof2 )*sum/energy;
00141   // result *= ( 1 - std::exp(-0.5*fPlateNumber*sigma) )/( 1 - std::exp(-0.5*sigma) );  
00142   // fPlateNumber;
00143   result *= ( 1 - dump + 2*dump*fPlateNumber ); 
00144   /*  
00145   fEnergy = energy;
00146   //  G4Integrator<G4VXTRenergyLoss,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
00147   G4Integrator<G4TransparentRegXTRadiator,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
00148  
00149   tmp = integral.Legendre96(this,&G4VXTRenergyLoss::SpectralAngleXTRdEdx,
00150                              0.0,0.3*fMaxThetaTR) +
00151       integral.Legendre96(this,&G4VXTRenergyLoss::SpectralAngleXTRdEdx,
00152                              0.3*fMaxThetaTR,0.6*fMaxThetaTR) +         
00153       integral.Legendre96(this,&G4VXTRenergyLoss::SpectralAngleXTRdEdx,
00154                              0.6*fMaxThetaTR,fMaxThetaTR) ;
00155   result += tmp;
00156   */
00157   return result;
00158 }


Public Member Functions
	G4RegularXTRadiator (G4LogicalVolume anEnvelope, G4Material , G4Material *, G4double, G4double, G4int, const G4String &processName="XTRegularRadiator")
	~G4RegularXTRadiator ()
G4double	SpectralXTRdEdx (G4double energy)
G4double	GetStackFactor (G4double energy, G4double gamma, G4double varAngle)

G4RegularXTRadiator Class Reference

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation