Geant4: G4TransparentRegXTRadiator Class Reference

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

Definition at line 42 of file G4TransparentRegXTRadiator.cc.

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

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

G4TransparentRegXTRadiator::~G4TransparentRegXTRadiator ( )

Definition at line 62 of file G4TransparentRegXTRadiator.cc.

00063 {
00064   ;
00065 }

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

Reimplemented from G4VXTRenergyLoss.

Definition at line 169 of file G4TransparentRegXTRadiator.cc.

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

00171 {
00172   /*
00173   G4double result, Za, Zb, Ma, Mb, sigma;
00174   
00175   Za = GetPlateFormationZone(energy,gamma,varAngle);
00176   Zb = GetGasFormationZone(energy,gamma,varAngle);
00177   Ma = GetPlateLinearPhotoAbs(energy);
00178   Mb = GetGasLinearPhotoAbs(energy);
00179   sigma = Ma*fPlateThick + Mb*fGasThick;
00180 
00181   G4complex Ca(1.0+0.5*fPlateThick*Ma/fAlphaPlate,fPlateThick/Za/fAlphaPlate); 
00182   G4complex Cb(1.0+0.5*fGasThick*Mb/fAlphaGas,fGasThick/Zb/fAlphaGas); 
00183 
00184   G4complex Ha = std::pow(Ca,-fAlphaPlate);  
00185   G4complex Hb = std::pow(Cb,-fAlphaGas);
00186   G4complex H  = Ha*Hb;
00187   G4complex F1 =   (1.0 - Ha)*(1.0 - Hb )/(1.0 - H)
00188                  * G4double(fPlateNumber) ;
00189   G4complex F2 =   (1.0-Ha)*(1.0-Ha)*Hb/(1.0-H)/(1.0-H)
00190                  * (1.0 - std::exp(-0.5*fPlateNumber*sigma)) ;
00191   //    *(1.0 - std::pow(H,fPlateNumber)) ;
00192     G4complex R  = (F1 + F2)*OneInterfaceXTRdEdx(energy,gamma,varAngle);
00193   // G4complex R  = F2*OneInterfaceXTRdEdx(energy,gamma,varAngle);
00194   result       = 2.0*std::real(R);  
00195   return      result;
00196   */
00197    // numerically unstable result
00198 
00199   G4double result, Qa, Qb, Q, aZa, bZb, aMa, bMb, D, sigma; 
00200  
00201   aZa   = fPlateThick/GetPlateFormationZone(energy,gamma,varAngle);
00202   bZb   = fGasThick/GetGasFormationZone(energy,gamma,varAngle);
00203   aMa   = fPlateThick*GetPlateLinearPhotoAbs(energy);
00204   bMb   = fGasThick*GetGasLinearPhotoAbs(energy);
00205   sigma = aMa*fPlateThick + bMb*fGasThick;
00206   Qa    = std::exp(-0.5*aMa);
00207   Qb    = std::exp(-0.5*bMb);
00208   Q     = Qa*Qb;
00209 
00210   G4complex Ha( Qa*std::cos(aZa), -Qa*std::sin(aZa)   );  
00211   G4complex Hb( Qb*std::cos(bZb), -Qb*std::sin(bZb)    );
00212   G4complex H  = Ha*Hb;
00213   G4complex Hs = conj(H);
00214   D            = 1.0 /( (1 - Q)*(1 - Q) + 
00215                   4*Q*std::sin(0.5*(aZa + bZb))*std::sin(0.5*(aZa + bZb)) );
00216   G4complex F1 = (1.0 - Ha)*(1.0 - Hb)*(1.0 - Hs)
00217                  * G4double(fPlateNumber)*D;
00218   G4complex F2 = (1.0 - Ha)*(1.0 - Ha)*Hb*(1.0 - Hs)*(1.0 - Hs)
00219                    // * (1.0 - std::pow(H,fPlateNumber)) * D*D;
00220                  * (1.0 - std::exp(-0.5*fPlateNumber*sigma)) * D*D;
00221   G4complex R  = (F1 + F2)*OneInterfaceXTRdEdx(energy,gamma,varAngle);
00222   result       = 2.0*std::real(R); 
00223   return      result;
00224   
00225 }

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

Reimplemented from G4VXTRenergyLoss.

Definition at line 71 of file G4TransparentRegXTRadiator.cc.

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

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


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

G4TransparentRegXTRadiator Class Reference

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation