G4VEmAdjointModel Class Reference

#include <G4VEmAdjointModel.hh>

Inheritance diagram for G4VEmAdjointModel:


Public Member Functions
	G4VEmAdjointModel (const G4String &nam)
virtual	~G4VEmAdjointModel ()
virtual void	SampleSecondaries (const G4Track &aTrack, G4bool IsScatProjToProjCase, G4ParticleChange *fParticleChange)=0
virtual G4double	AdjointCrossSection (const G4MaterialCutsCouple *aCouple, G4double primEnergy, G4bool IsScatProjToProjCase)
virtual G4double	GetAdjointCrossSection (const G4MaterialCutsCouple *aCouple, G4double primEnergy, G4bool IsScatProjToProjCase)
virtual G4double	DiffCrossSectionPerAtomPrimToSecond (G4double kinEnergyProj, G4double kinEnergyProd, G4double Z, G4double A=0.)
virtual G4double	DiffCrossSectionPerAtomPrimToScatPrim (G4double kinEnergyProj, G4double kinEnergyScatProj, G4double Z, G4double A=0.)
virtual G4double	DiffCrossSectionPerVolumePrimToSecond (const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyProd)
virtual G4double	DiffCrossSectionPerVolumePrimToScatPrim (const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyScatProj)
virtual G4double	GetSecondAdjEnergyMaxForScatProjToProjCase (G4double PrimAdjEnergy)
virtual G4double	GetSecondAdjEnergyMinForScatProjToProjCase (G4double PrimAdjEnergy, G4double Tcut=0)
virtual G4double	GetSecondAdjEnergyMaxForProdToProjCase (G4double PrimAdjEnergy)
virtual G4double	GetSecondAdjEnergyMinForProdToProjCase (G4double PrimAdjEnergy)
void	DefineCurrentMaterial (const G4MaterialCutsCouple *couple)
std::vector< std::vector< double > * >	ComputeAdjointCrossSectionVectorPerAtomForSecond (G4double kinEnergyProd, G4double Z, G4double A=0., G4int nbin_pro_decade=10)
std::vector< std::vector< double > * >	ComputeAdjointCrossSectionVectorPerAtomForScatProj (G4double kinEnergyProd, G4double Z, G4double A=0., G4int nbin_pro_decade=10)
std::vector< std::vector< double > * >	ComputeAdjointCrossSectionVectorPerVolumeForSecond (G4Material *aMaterial, G4double kinEnergyProd, G4int nbin_pro_decade=10)
std::vector< std::vector< double > * >	ComputeAdjointCrossSectionVectorPerVolumeForScatProj (G4Material *aMaterial, G4double kinEnergyProd, G4int nbin_pro_decade=10)
void	SetCSMatrices (std::vector< G4AdjointCSMatrix * > Vec1CSMatrix, std::vector< G4AdjointCSMatrix > *Vec2CSMatrix)
G4ParticleDefinition *	GetAdjointEquivalentOfDirectPrimaryParticleDefinition ()
G4ParticleDefinition *	GetAdjointEquivalentOfDirectSecondaryParticleDefinition ()
G4double	GetHighEnergyLimit ()
G4double	GetLowEnergyLimit ()
void	SetHighEnergyLimit (G4double aVal)
void	SetLowEnergyLimit (G4double aVal)
void	DefineDirectEMModel (G4VEmModel *aModel)
void	SetAdjointEquivalentOfDirectPrimaryParticleDefinition (G4ParticleDefinition *aPart)
void	SetAdjointEquivalentOfDirectSecondaryParticleDefinition (G4ParticleDefinition *aPart)
void	SetSecondPartOfSameType (G4bool aBool)
G4bool	GetSecondPartOfSameType ()
void	SetUseMatrix (G4bool aBool)
void	SetUseMatrixPerElement (G4bool aBool)
void	SetUseOnlyOneMatrixForAllElements (G4bool aBool)
void	SetApplyCutInRange (G4bool aBool)
G4bool	GetUseMatrix ()
G4bool	GetUseMatrixPerElement ()
G4bool	GetUseOnlyOneMatrixForAllElements ()
G4bool	GetApplyCutInRange ()
G4String	GetName ()
virtual void	SetCSBiasingFactor (G4double aVal)
Protected Member Functions
G4double	DiffCrossSectionFunction1 (G4double kinEnergyProj)
G4double	DiffCrossSectionFunction2 (G4double kinEnergyProj)
G4double	DiffCrossSectionPerVolumeFunctionForIntegrationOverEkinProj (G4double EkinProd)
G4double	SampleAdjSecEnergyFromCSMatrix (size_t MatrixIndex, G4double prim_energy, G4bool IsScatProjToProjCase)
G4double	SampleAdjSecEnergyFromCSMatrix (G4double prim_energy, G4bool IsScatProjToProjCase)
void	SelectCSMatrix (G4bool IsScatProjToProjCase)
virtual G4double	SampleAdjSecEnergyFromDiffCrossSectionPerAtom (G4double prim_energy, G4bool IsScatProjToProjCase)
virtual void	CorrectPostStepWeight (G4ParticleChange *fParticleChange, G4double old_weight, G4double adjointPrimKinEnergy, G4double projectileKinEnergy, G4bool IsScatProjToProjCase)
Protected Attributes
G4VEmModel *	theDirectEMModel
G4VParticleChange *	pParticleChange
const G4String	name
G4int	ASelectedNucleus
G4int	ZSelectedNucleus
G4Material *	SelectedMaterial
G4double	kinEnergyProdForIntegration
G4double	kinEnergyScatProjForIntegration
G4double	kinEnergyProjForIntegration
std::vector< G4AdjointCSMatrix * > *	pOnCSMatrixForProdToProjBackwardScattering
std::vector< G4AdjointCSMatrix * > *	pOnCSMatrixForScatProjToProjBackwardScattering
std::vector< G4double >	CS_Vs_ElementForScatProjToProjCase
std::vector< G4double >	CS_Vs_ElementForProdToProjCase
G4double	lastCS
G4double	lastAdjointCSForScatProjToProjCase
G4double	lastAdjointCSForProdToProjCase
G4ParticleDefinition *	theAdjEquivOfDirectPrimPartDef
G4ParticleDefinition *	theAdjEquivOfDirectSecondPartDef
G4ParticleDefinition *	theDirectPrimaryPartDef
G4bool	second_part_of_same_type
G4double	preStepEnergy
G4Material *	currentMaterial
G4MaterialCutsCouple *	currentCouple
size_t	currentMaterialIndex
size_t	currentCoupleIndex
G4double	currentTcutForDirectPrim
G4double	currentTcutForDirectSecond
G4bool	ApplyCutInRange
G4double	mass_ratio_product
G4double	mass_ratio_projectile
G4double	HighEnergyLimit
G4double	LowEnergyLimit
G4double	CS_biasing_factor
G4bool	UseMatrix
G4bool	UseMatrixPerElement
G4bool	UseOnlyOneMatrixForAllElements
size_t	indexOfUsedCrossSectionMatrix
size_t	model_index

Detailed Description

Definition at line 72 of file G4VEmAdjointModel.hh.

Constructor & Destructor Documentation

G4VEmAdjointModel::G4VEmAdjointModel ( const G4String & nam )

Definition at line 41 of file G4VEmAdjointModel.cc.

References currentCouple, G4AdjointCSManager::GetAdjointCSManager(), mass_ratio_product, mass_ratio_projectile, model_index, G4AdjointCSManager::RegisterEmAdjointModel(), second_part_of_same_type, and theDirectEMModel.

00041                                                        :
00042 name(nam)
00043 // lowLimit(0.1*keV), highLimit(100.0*TeV), fluc(0), name(nam), pParticleChange(0)
00044 { 
00045   model_index = G4AdjointCSManager::GetAdjointCSManager()->RegisterEmAdjointModel(this);
00046   second_part_of_same_type =false;
00047   theDirectEMModel=0;
00048   mass_ratio_product=1.;
00049   mass_ratio_projectile=1.;
00050   currentCouple=0;
00051 }

G4VEmAdjointModel::~G4VEmAdjointModel ( ) [virtual]

Definition at line 54 of file G4VEmAdjointModel.cc.

00055 {;}

Member Function Documentation

G4double G4VEmAdjointModel::AdjointCrossSection	(	const G4MaterialCutsCouple *	aCouple,
		G4double	primEnergy,
		G4bool	IsScatProjToProjCase
	)			`[virtual]`

Reimplemented in G4AdjointBremsstrahlungModel, G4AdjointComptonModel, G4AdjointhIonisationModel, and G4AdjointPhotoElectricModel.

Definition at line 58 of file G4VEmAdjointModel.cc.

References G4AdjointCSManager::ComputeAdjointCS(), CS_Vs_ElementForProdToProjCase, CS_Vs_ElementForScatProjToProjCase, currentMaterial, currentTcutForDirectSecond, DefineCurrentMaterial(), G4AdjointCSManager::GetAdjointCSManager(), lastAdjointCSForProdToProjCase, lastAdjointCSForScatProjToProjCase, lastCS, and preStepEnergy.

00061 { 
00062   DefineCurrentMaterial(aCouple);
00063   preStepEnergy=primEnergy;
00064   
00065   std::vector<G4double>* CS_Vs_Element = &CS_Vs_ElementForProdToProjCase;
00066   if (IsScatProjToProjCase)   CS_Vs_Element = &CS_Vs_ElementForScatProjToProjCase;
00067   lastCS = G4AdjointCSManager::GetAdjointCSManager()->ComputeAdjointCS(currentMaterial,
00068                                                                         this, 
00069                                                                         primEnergy,
00070                                                                         currentTcutForDirectSecond,
00071                                                                         IsScatProjToProjCase,
00072                                                                         *CS_Vs_Element);
00073   if (IsScatProjToProjCase) lastAdjointCSForScatProjToProjCase = lastCS;
00074   else lastAdjointCSForProdToProjCase =lastCS;                                                          
00075         
00076  
00077  
00078   return lastCS;
00079                                                                         
00080 }

std::vector< std::vector< G4double > * > G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerAtomForScatProj	(	G4double	kinEnergyProd,
		G4double	Z,
		G4double	A = `0.`,
		G4int	nbin_pro_decade = `10`
	)

Definition at line 291 of file G4VEmAdjointModel.cc.

References ASelectedNucleus, DiffCrossSectionFunction2(), GetLowEnergyLimit(), GetSecondAdjEnergyMaxForScatProjToProjCase(), GetSecondAdjEnergyMinForScatProjToProjCase(), kinEnergyScatProjForIntegration, G4Integrator< T, F >::Simpson(), and ZSelectedNucleus.

00296 { G4Integrator<G4VEmAdjointModel, double(G4VEmAdjointModel::*)(double)> integral;
00297   ASelectedNucleus=int(A);
00298   ZSelectedNucleus=int(Z);
00299   kinEnergyScatProjForIntegration = kinEnergyScatProj;
00300   
00301   //compute the vector of integrated cross sections
00302   //-------------------
00303   
00304   G4double minEProj= GetSecondAdjEnergyMinForScatProjToProjCase(kinEnergyScatProj); 
00305   G4double maxEProj= GetSecondAdjEnergyMaxForScatProjToProjCase(kinEnergyScatProj);
00306   G4double dEmax=maxEProj-kinEnergyScatProj;
00307   G4double dEmin=GetLowEnergyLimit();
00308   G4double dE1=dEmin;
00309   G4double dE2=dEmin;
00310   
00311   
00312   std::vector< double>*  log_ESec_vector = new std::vector< double>();
00313   std::vector< double>*  log_Prob_vector = new std::vector< double>();
00314   log_ESec_vector->push_back(std::log(dEmin));
00315   log_Prob_vector->push_back(-50.);
00316   G4int nbins=std::max( int(std::log10(dEmax/dEmin))*nbin_pro_decade,5);
00317   G4double fE=std::pow(dEmax/dEmin,1./nbins);
00318   
00319   
00320   
00321   
00322   
00323   G4double int_cross_section=0.;
00324   
00325   while (dE1 <dEmax*0.9999999999999){
00326         dE2=dE1*fE;
00327         int_cross_section +=integral.Simpson(this,
00328         &G4VEmAdjointModel::DiffCrossSectionFunction2,minEProj+dE1,std::min(minEProj+dE2,maxEProj), 5);
00329         //G4cout<<"int_cross_section "<<minEProj+dE1<<'\t'<<int_cross_section<<G4endl;
00330         log_ESec_vector->push_back(std::log(std::min(dE2,maxEProj-minEProj)));
00331         log_Prob_vector->push_back(std::log(int_cross_section));        
00332         dE1=dE2;
00333 
00334   }
00335   
00336   
00337   std::vector< std::vector<G4double> *> res_mat; 
00338   res_mat.clear();
00339   if (int_cross_section >0.) {
00340         res_mat.push_back(log_ESec_vector);
00341         res_mat.push_back(log_Prob_vector);
00342   }     
00343   
00344   return res_mat;
00345 }

std::vector< std::vector< G4double > * > G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerAtomForSecond	(	G4double	kinEnergyProd,
		G4double	Z,
		G4double	A = `0.`,
		G4int	nbin_pro_decade = `10`
	)

Definition at line 238 of file G4VEmAdjointModel.cc.

References ASelectedNucleus, DiffCrossSectionFunction1(), GetSecondAdjEnergyMaxForProdToProjCase(), GetSecondAdjEnergyMinForProdToProjCase(), kinEnergyProdForIntegration, G4Integrator< T, F >::Simpson(), and ZSelectedNucleus.

00243 { 
00244   G4Integrator<G4VEmAdjointModel, double(G4VEmAdjointModel::*)(double)> integral;
00245   ASelectedNucleus= int(A);
00246   ZSelectedNucleus=int(Z);
00247   kinEnergyProdForIntegration = kinEnergyProd;
00248   
00249   //compute the vector of integrated cross sections
00250   //-------------------
00251   
00252   G4double minEProj= GetSecondAdjEnergyMinForProdToProjCase(kinEnergyProd);
00253   G4double maxEProj= GetSecondAdjEnergyMaxForProdToProjCase(kinEnergyProd);
00254   G4double E1=minEProj;
00255   std::vector< double>*  log_ESec_vector = new  std::vector< double>();
00256   std::vector< double>*  log_Prob_vector = new  std::vector< double>();
00257   log_ESec_vector->clear();
00258   log_Prob_vector->clear();
00259   log_ESec_vector->push_back(std::log(E1));
00260   log_Prob_vector->push_back(-50.);
00261   
00262   G4double E2=std::pow(10.,double( int(std::log10(minEProj)*nbin_pro_decade)+1)/nbin_pro_decade);
00263   G4double fE=std::pow(10.,1./nbin_pro_decade);
00264   G4double int_cross_section=0.;
00265   
00266   if (std::pow(fE,5.)>(maxEProj/minEProj)) fE = std::pow(maxEProj/minEProj,0.2);
00267   
00268   while (E1 <maxEProj*0.9999999){
00269         //G4cout<<E1<<'\t'<<E2<<G4endl;
00270         
00271         int_cross_section +=integral.Simpson(this,
00272         &G4VEmAdjointModel::DiffCrossSectionFunction1,E1,std::min(E2,maxEProj*0.99999999), 5);
00273         log_ESec_vector->push_back(std::log(std::min(E2,maxEProj)));
00274         log_Prob_vector->push_back(std::log(int_cross_section));        
00275         E1=E2;
00276         E2*=fE;
00277   
00278   }
00279   std::vector< std::vector<G4double>* > res_mat;
00280   res_mat.clear();
00281   if (int_cross_section >0.) {
00282         res_mat.push_back(log_ESec_vector);
00283         res_mat.push_back(log_Prob_vector);
00284   }     
00285   
00286   return res_mat;
00287 }

std::vector< std::vector< G4double > * > G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForScatProj	(	G4Material *	aMaterial,
		G4double	kinEnergyProd,
		G4int	nbin_pro_decade = `10`
	)

Definition at line 399 of file G4VEmAdjointModel.cc.

References DiffCrossSectionFunction2(), GetLowEnergyLimit(), GetSecondAdjEnergyMaxForScatProjToProjCase(), GetSecondAdjEnergyMinForScatProjToProjCase(), kinEnergyScatProjForIntegration, SelectedMaterial, and G4Integrator< T, F >::Simpson().

00403 { G4Integrator<G4VEmAdjointModel, double(G4VEmAdjointModel::*)(double)> integral;
00404   SelectedMaterial= aMaterial;
00405   kinEnergyScatProjForIntegration = kinEnergyScatProj;
00406  
00407   //compute the vector of integrated cross sections
00408   //-------------------
00409   
00410   G4double minEProj= GetSecondAdjEnergyMinForScatProjToProjCase(kinEnergyScatProj);
00411   G4double maxEProj= GetSecondAdjEnergyMaxForScatProjToProjCase(kinEnergyScatProj);
00412  
00413   
00414   G4double dEmax=maxEProj-kinEnergyScatProj;
00415   G4double dEmin=GetLowEnergyLimit();
00416   G4double dE1=dEmin;
00417   G4double dE2=dEmin;
00418   
00419   
00420   std::vector< double>*  log_ESec_vector = new std::vector< double>();
00421   std::vector< double>*  log_Prob_vector = new std::vector< double>();
00422   log_ESec_vector->push_back(std::log(dEmin));
00423   log_Prob_vector->push_back(-50.);
00424   G4int nbins=std::max( int(std::log10(dEmax/dEmin))*nbin_pro_decade,5);
00425   G4double fE=std::pow(dEmax/dEmin,1./nbins);
00426   
00427   G4double int_cross_section=0.;
00428   
00429   while (dE1 <dEmax*0.9999999999999){
00430         dE2=dE1*fE;
00431         int_cross_section +=integral.Simpson(this,
00432         &G4VEmAdjointModel::DiffCrossSectionFunction2,minEProj+dE1,std::min(minEProj+dE2,maxEProj), 5);
00433         log_ESec_vector->push_back(std::log(std::min(dE2,maxEProj-minEProj)));
00434         log_Prob_vector->push_back(std::log(int_cross_section));
00435         dE1=dE2;
00436 
00437   }
00438   
00439   
00440   
00441   
00442   
00443   std::vector< std::vector<G4double> *> res_mat;
00444   res_mat.clear();
00445   if (int_cross_section >0.) {
00446         res_mat.push_back(log_ESec_vector);
00447         res_mat.push_back(log_Prob_vector);
00448   }     
00449   
00450   return res_mat;
00451 }

std::vector< std::vector< G4double > * > G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForSecond	(	G4Material *	aMaterial,
		G4double	kinEnergyProd,
		G4int	nbin_pro_decade = `10`
	)

Definition at line 348 of file G4VEmAdjointModel.cc.

References DiffCrossSectionFunction1(), GetSecondAdjEnergyMaxForProdToProjCase(), GetSecondAdjEnergyMinForProdToProjCase(), kinEnergyProdForIntegration, SelectedMaterial, and G4Integrator< T, F >::Simpson().

00352 { G4Integrator<G4VEmAdjointModel, double(G4VEmAdjointModel::*)(double)> integral;
00353   SelectedMaterial= aMaterial;
00354   kinEnergyProdForIntegration = kinEnergyProd;
00355    //compute the vector of integrated cross sections
00356   //-------------------
00357   
00358   G4double minEProj= GetSecondAdjEnergyMinForProdToProjCase(kinEnergyProd);
00359   G4double maxEProj= GetSecondAdjEnergyMaxForProdToProjCase(kinEnergyProd);
00360   G4double E1=minEProj;
00361   std::vector< double>*  log_ESec_vector = new  std::vector< double>();
00362   std::vector< double>*  log_Prob_vector = new  std::vector< double>();
00363   log_ESec_vector->clear();
00364   log_Prob_vector->clear();
00365   log_ESec_vector->push_back(std::log(E1));
00366   log_Prob_vector->push_back(-50.);
00367   
00368   G4double E2=std::pow(10.,double( int(std::log10(minEProj)*nbin_pro_decade)+1)/nbin_pro_decade);
00369   G4double fE=std::pow(10.,1./nbin_pro_decade);
00370   G4double int_cross_section=0.;
00371   
00372   if (std::pow(fE,5.)>(maxEProj/minEProj)) fE = std::pow(maxEProj/minEProj,0.2);
00373   
00374   while (E1 <maxEProj*0.9999999){
00375         
00376         int_cross_section +=integral.Simpson(this,
00377         &G4VEmAdjointModel::DiffCrossSectionFunction1,E1,std::min(E2,maxEProj*0.99999999), 5);
00378         log_ESec_vector->push_back(std::log(std::min(E2,maxEProj)));
00379         log_Prob_vector->push_back(std::log(int_cross_section));
00380         E1=E2;
00381         E2*=fE;
00382   
00383   }
00384   std::vector< std::vector<G4double>* > res_mat;
00385   res_mat.clear();
00386   
00387   if (int_cross_section >0.) {
00388         res_mat.push_back(log_ESec_vector);
00389         res_mat.push_back(log_Prob_vector);
00390   }
00391   
00392  
00393   
00394   return res_mat;
00395 }

void G4VEmAdjointModel::CorrectPostStepWeight	(	G4ParticleChange *	fParticleChange,
		G4double	old_weight,
		G4double	adjointPrimKinEnergy,
		G4double	projectileKinEnergy,
		G4bool	IsScatProjToProjCase
	)			`[protected, virtual]`

Reimplemented in G4AdjointIonIonisationModel, and G4AdjointPhotoElectricModel.

Definition at line 624 of file G4VEmAdjointModel.cc.

References AdjointCrossSection(), CS_biasing_factor, currentCouple, G4AdjointCSManager::GetAdjointCSManager(), G4AdjointCSManager::GetPostStepWeightCorrection(), lastAdjointCSForProdToProjCase, lastAdjointCSForScatProjToProjCase, lastCS, preStepEnergy, G4VParticleChange::ProposeParentWeight(), G4VParticleChange::SetParentWeightByProcess(), and G4VParticleChange::SetSecondaryWeightByProcess().

Referenced by G4AdjointhIonisationModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), and G4AdjointBremsstrahlungModel::SampleSecondaries().

00629 {
00630  G4double new_weight=old_weight;
00631  G4double w_corr =1./CS_biasing_factor;
00632  w_corr*=G4AdjointCSManager::GetAdjointCSManager()->GetPostStepWeightCorrection();
00633  
00634  
00635  lastCS=lastAdjointCSForScatProjToProjCase;
00636  if ( !IsScatProjToProjCase) lastCS=lastAdjointCSForProdToProjCase;
00637  if ((adjointPrimKinEnergy-preStepEnergy)/preStepEnergy>0.001){ //Is that in all cases needed???
00638         G4double post_stepCS=AdjointCrossSection(currentCouple, adjointPrimKinEnergy
00639                                                  ,IsScatProjToProjCase );
00640         if (post_stepCS>0 && lastCS>0) w_corr*=post_stepCS/lastCS;
00641  }
00642         
00643  new_weight*=w_corr;
00644 
00645  //G4cout<<"Post step "<<new_weight<<'\t'<<w_corr<<'\t'<<old_weight<<G4endl;
00646  new_weight*=projectileKinEnergy/adjointPrimKinEnergy;//This is needed due to the biasing of diff CS
00647                                                         //by the factor adjointPrimKinEnergy/projectileKinEnergy
00648    
00649 
00650 
00651  fParticleChange->SetParentWeightByProcess(false);
00652  fParticleChange->SetSecondaryWeightByProcess(false);
00653  fParticleChange->ProposeParentWeight(new_weight);      
00654 }

void G4VEmAdjointModel::DefineCurrentMaterial ( const G4MaterialCutsCouple * couple )

Definition at line 683 of file G4VEmAdjointModel.cc.

References G4AdjointElectron::AdjointElectron(), G4AdjointGamma::AdjointGamma(), G4AdjointPositron::AdjointPositron(), currentCouple, currentCoupleIndex, currentMaterial, currentMaterialIndex, currentTcutForDirectSecond, G4ProductionCutsTable::GetEnergyCutsVector(), G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetProductionCutsTable(), and theAdjEquivOfDirectSecondPartDef.

Referenced by AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), G4AdjointComptonModel::AdjointCrossSection(), G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), and G4AdjointBremsstrahlungModel::SampleSecondaries().

00684 { if(couple != currentCouple) {
00685         currentCouple   = const_cast<G4MaterialCutsCouple*> (couple);
00686         currentMaterial = const_cast<G4Material*> (couple->GetMaterial());
00687         currentCoupleIndex = couple->GetIndex();
00688         currentMaterialIndex = currentMaterial->GetIndex();
00689         size_t idx=56;
00690         currentTcutForDirectSecond =0.00000000001;
00691         if (theAdjEquivOfDirectSecondPartDef) {
00692                 if (theAdjEquivOfDirectSecondPartDef == G4AdjointGamma::AdjointGamma()) idx = 0;
00693                 else if (theAdjEquivOfDirectSecondPartDef == G4AdjointElectron::AdjointElectron()) idx = 1;
00694                 else if (theAdjEquivOfDirectSecondPartDef == G4AdjointPositron::AdjointPositron()) idx = 2;
00695                 if (idx <56){
00696                         const std::vector<G4double>* aVec = G4ProductionCutsTable::GetProductionCutsTable()->GetEnergyCutsVector(idx);
00697                         currentTcutForDirectSecond=(*aVec)[currentCoupleIndex];
00698                 }       
00699         }       
00700     
00701         
00702   }
00703 }

void G4VEmAdjointModel::DefineDirectEMModel ( G4VEmModel * aModel ) [inline]

Definition at line 193 of file G4VEmAdjointModel.hh.

References theDirectEMModel.

Referenced by G4AdjointPhotoElectricModel::SetTheDirectPEEffectModel().

00193 {theDirectEMModel = aModel;}

G4double G4VEmAdjointModel::DiffCrossSectionFunction1 ( G4double kinEnergyProj ) [protected]

Definition at line 201 of file G4VEmAdjointModel.cc.

References ASelectedNucleus, CS_biasing_factor, DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerVolumePrimToSecond(), kinEnergyProdForIntegration, SelectedMaterial, UseMatrixPerElement, and ZSelectedNucleus.

Referenced by ComputeAdjointCrossSectionVectorPerAtomForSecond(), and ComputeAdjointCrossSectionVectorPerVolumeForSecond().

00201                                                                            {
00202   
00203   
00204   G4double bias_factor = CS_biasing_factor*kinEnergyProdForIntegration/kinEnergyProj;   
00205 
00206 
00207   if (UseMatrixPerElement ) {
00208         return DiffCrossSectionPerAtomPrimToSecond(kinEnergyProj,kinEnergyProdForIntegration,ZSelectedNucleus,ASelectedNucleus)*bias_factor;
00209   }
00210   else  {
00211         return DiffCrossSectionPerVolumePrimToSecond(SelectedMaterial,kinEnergyProj,kinEnergyProdForIntegration)*bias_factor;
00212   }     
00213 }

G4double G4VEmAdjointModel::DiffCrossSectionFunction2 ( G4double kinEnergyProj ) [protected]

Definition at line 217 of file G4VEmAdjointModel.cc.

References ASelectedNucleus, CS_biasing_factor, DiffCrossSectionPerAtomPrimToScatPrim(), DiffCrossSectionPerVolumePrimToScatPrim(), kinEnergyScatProjForIntegration, SelectedMaterial, UseMatrixPerElement, and ZSelectedNucleus.

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), and ComputeAdjointCrossSectionVectorPerVolumeForScatProj().

00217                                                                            {
00218   
00219  G4double bias_factor =  CS_biasing_factor*kinEnergyScatProjForIntegration/kinEnergyProj;
00220  if (UseMatrixPerElement ) {
00221         return DiffCrossSectionPerAtomPrimToScatPrim(kinEnergyProj,kinEnergyScatProjForIntegration,ZSelectedNucleus,ASelectedNucleus)*bias_factor;
00222  }      
00223  else {  
00224         return DiffCrossSectionPerVolumePrimToScatPrim(SelectedMaterial,kinEnergyProj,kinEnergyScatProjForIntegration)*bias_factor;
00225  
00226  }      
00227                 
00228 }

G4double G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToScatPrim	(	G4double	kinEnergyProj,
		G4double	kinEnergyScatProj,
		G4double	Z,
		G4double	A = `0.`
	)			`[virtual]`

Reimplemented in G4AdjointComptonModel.

Definition at line 144 of file G4VEmAdjointModel.cc.

References DiffCrossSectionPerAtomPrimToSecond().

Referenced by DiffCrossSectionFunction2(), and SampleAdjSecEnergyFromDiffCrossSectionPerAtom().

00149 { G4double kinEnergyProd = kinEnergyProj - kinEnergyScatProj;
00150   G4double dSigmadEprod;
00151   if (kinEnergyProd <=0) dSigmadEprod=0;
00152   else dSigmadEprod=DiffCrossSectionPerAtomPrimToSecond(kinEnergyProj,kinEnergyProd,Z,A);
00153   return dSigmadEprod;  
00154 
00155 }

G4double G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond	(	G4double	kinEnergyProj,
		G4double	kinEnergyProd,
		G4double	Z,
		G4double	A = `0.`
	)			`[virtual]`

Reimplemented in G4AdjointComptonModel, G4AdjointeIonisationModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 112 of file G4VEmAdjointModel.cc.

References G4VEmModel::ComputeCrossSectionPerAtom(), GetSecondAdjEnergyMaxForProdToProjCase(), GetSecondAdjEnergyMinForProdToProjCase(), theDirectEMModel, and theDirectPrimaryPartDef.

Referenced by DiffCrossSectionFunction1(), DiffCrossSectionPerAtomPrimToScatPrim(), and SampleAdjSecEnergyFromDiffCrossSectionPerAtom().

00117 {
00118  G4double dSigmadEprod=0;
00119  G4double Emax_proj = GetSecondAdjEnergyMaxForProdToProjCase(kinEnergyProd);
00120  G4double Emin_proj = GetSecondAdjEnergyMinForProdToProjCase(kinEnergyProd);
00121  
00122  
00123  if (kinEnergyProj>Emin_proj && kinEnergyProj<=Emax_proj){ //the produced particle should have a kinetic energy smaller than the projectile 
00124         
00125         /*G4double Tmax=kinEnergyProj;
00126         if (second_part_of_same_type) Tmax = kinEnergyProj/2.;*/
00127 
00128         G4double E1=kinEnergyProd;
00129         G4double E2=kinEnergyProd*1.000001;
00130         G4double dE=(E2-E1);
00131         G4double sigma1=theDirectEMModel->ComputeCrossSectionPerAtom(theDirectPrimaryPartDef,kinEnergyProj,Z,A ,E1,1.e20);
00132         G4double sigma2=theDirectEMModel->ComputeCrossSectionPerAtom(theDirectPrimaryPartDef,kinEnergyProj,Z,A ,E2,1.e20);
00133         
00134         dSigmadEprod=(sigma1-sigma2)/dE;
00135  }
00136  return dSigmadEprod;   
00137  
00138  
00139  
00140 }

G4double G4VEmAdjointModel::DiffCrossSectionPerVolumeFunctionForIntegrationOverEkinProj ( G4double EkinProd ) [protected]

Definition at line 232 of file G4VEmAdjointModel.cc.

References DiffCrossSectionPerVolumePrimToSecond(), kinEnergyProjForIntegration, and SelectedMaterial.

00233 {
00234   return DiffCrossSectionPerVolumePrimToSecond(SelectedMaterial,kinEnergyProjForIntegration,kinEnergyProd);
00235 }

G4double G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToScatPrim	(	const G4Material *	aMaterial,
		G4double	kinEnergyProj,
		G4double	kinEnergyScatProj
	)			`[virtual]`

Definition at line 188 of file G4VEmAdjointModel.cc.

References DiffCrossSectionPerVolumePrimToSecond().

Referenced by DiffCrossSectionFunction2(), and G4AdjointeIonisationModel::SampleSecondaries().

00192 { G4double kinEnergyProd = kinEnergyProj - kinEnergyScatProj;
00193   G4double dSigmadEprod;
00194   if (kinEnergyProd <=0) dSigmadEprod=0;
00195   else dSigmadEprod=DiffCrossSectionPerVolumePrimToSecond(aMaterial,kinEnergyProj,kinEnergyProd);
00196   return dSigmadEprod;  
00197 
00198 }

G4double G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond	(	const G4Material *	aMaterial,
		G4double	kinEnergyProj,
		G4double	kinEnergyProd
	)			`[virtual]`

Reimplemented in G4AdjointBremsstrahlungModel.

Definition at line 160 of file G4VEmAdjointModel.cc.

References G4VEmModel::CrossSectionPerVolume(), GetSecondAdjEnergyMaxForProdToProjCase(), GetSecondAdjEnergyMinForProdToProjCase(), theDirectEMModel, and theDirectPrimaryPartDef.

Referenced by DiffCrossSectionFunction1(), DiffCrossSectionPerVolumeFunctionForIntegrationOverEkinProj(), DiffCrossSectionPerVolumePrimToScatPrim(), and G4AdjointeIonisationModel::SampleSecondaries().

00164 {
00165  G4double dSigmadEprod=0;
00166  G4double Emax_proj = GetSecondAdjEnergyMaxForProdToProjCase(kinEnergyProd);
00167  G4double Emin_proj = GetSecondAdjEnergyMinForProdToProjCase(kinEnergyProd);
00168  
00169  
00170  if (kinEnergyProj>Emin_proj && kinEnergyProj<=Emax_proj){ 
00171         /*G4double Tmax=kinEnergyProj;
00172         if (second_part_of_same_type) Tmax = kinEnergyProj/2.;*/
00173         G4double E1=kinEnergyProd;
00174         G4double E2=kinEnergyProd*1.0001;
00175         G4double dE=(E2-E1);
00176         G4double sigma1=theDirectEMModel->CrossSectionPerVolume(aMaterial,theDirectPrimaryPartDef,kinEnergyProj,E1,1.e20);
00177     G4double sigma2=theDirectEMModel->CrossSectionPerVolume(aMaterial,theDirectPrimaryPartDef,kinEnergyProj,E2,1.e20);
00178         dSigmadEprod=(sigma1-sigma2)/dE;
00179  }
00180  return dSigmadEprod;   
00181  
00182  
00183  
00184 }

G4double G4VEmAdjointModel::GetAdjointCrossSection	(	const G4MaterialCutsCouple *	aCouple,
		G4double	primEnergy,
		G4bool	IsScatProjToProjCase
	)			`[virtual]`

Reimplemented in G4AdjointBremsstrahlungModel, G4AdjointComptonModel, and G4AdjointPhotoElectricModel.

Definition at line 83 of file G4VEmAdjointModel.cc.

References AdjointCrossSection().

Referenced by G4AdjointBremsstrahlungModel::GetAdjointCrossSection(), and G4VAdjointReverseReaction::GetMeanFreePath().

00086 {
00087   return AdjointCrossSection(aCouple, primEnergy,
00088                                 IsScatProjToProjCase);
00089   
00090   /*
00091   //To continue
00092   DefineCurrentMaterial(aCouple);
00093   preStepEnergy=primEnergy;
00094   if (IsScatProjToProjCase){
00095         G4double ekin=primEnergy*mass_ratio_projectile;
00096         lastCS = G4AdjointCSManager::GetAdjointCSManager()->GetAdjointSigma(ekin, model_index,true, aCouple);
00097         lastAdjointCSForScatProjToProjCase = lastCS;
00098         //G4cout<<ekin<<std::endl;
00099   }
00100   else {
00101         G4double ekin=primEnergy*mass_ratio_product;
00102         lastCS = G4AdjointCSManager::GetAdjointCSManager()->GetAdjointSigma(ekin, model_index,false, aCouple);
00103         lastAdjointCSForProdToProjCase = lastCS;
00104         //G4cout<<ekin<<std::endl;
00105   }
00106   return lastCS;
00107   */
00108 }

G4ParticleDefinition* G4VEmAdjointModel::GetAdjointEquivalentOfDirectPrimaryParticleDefinition ( ) [inline]

Definition at line 181 of file G4VEmAdjointModel.hh.

References theAdjEquivOfDirectPrimPartDef.

00181 {return theAdjEquivOfDirectPrimPartDef;}

G4ParticleDefinition* G4VEmAdjointModel::GetAdjointEquivalentOfDirectSecondaryParticleDefinition ( ) [inline]

Definition at line 183 of file G4VEmAdjointModel.hh.

References theAdjEquivOfDirectSecondPartDef.

00183 {return theAdjEquivOfDirectSecondPartDef;}

G4bool G4VEmAdjointModel::GetApplyCutInRange ( ) [inline]

Definition at line 214 of file G4VEmAdjointModel.hh.

References ApplyCutInRange.

Referenced by G4AdjointCSManager::ComputeAdjointCS().

00214 { return ApplyCutInRange;}

G4double G4VEmAdjointModel::GetHighEnergyLimit ( ) [inline]

Definition at line 185 of file G4VEmAdjointModel.hh.

References HighEnergyLimit.

00185 {return HighEnergyLimit;}

G4double G4VEmAdjointModel::GetLowEnergyLimit ( ) [inline]

Definition at line 187 of file G4VEmAdjointModel.hh.

References LowEnergyLimit.

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), and ComputeAdjointCrossSectionVectorPerVolumeForScatProj().

00187 {return LowEnergyLimit;}

G4String G4VEmAdjointModel::GetName ( ) [inline]

Definition at line 216 of file G4VEmAdjointModel.hh.

References name.

00216 { return name;}

G4double G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProjCase ( G4double PrimAdjEnergy ) [virtual]

Reimplemented in G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 671 of file G4VEmAdjointModel.cc.

References HighEnergyLimit.

Referenced by G4AdjointComptonModel::AdjointCrossSection(), G4AdjointBremsstrahlungModel::AdjointCrossSection(), ComputeAdjointCrossSectionVectorPerAtomForSecond(), ComputeAdjointCrossSectionVectorPerVolumeForSecond(), G4AdjointCSManager::ComputeAdjointCS(), DiffCrossSectionPerAtomPrimToSecond(), G4AdjointeIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerVolumePrimToSecond(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated1(), G4AdjointComptonModel::RapidSampleSecondaries(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), SampleAdjSecEnergyFromCSMatrix(), SampleAdjSecEnergyFromDiffCrossSectionPerAtom(), and G4AdjointeIonisationModel::SampleSecondaries().

00672 { return HighEnergyLimit;
00673 }

G4double G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProjCase ( G4double PrimAdjEnergy ) [virtual]

Reimplemented in G4AdjointComptonModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 657 of file G4VEmAdjointModel.cc.

References HighEnergyLimit, and second_part_of_same_type.

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), ComputeAdjointCrossSectionVectorPerAtomForScatProj(), ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), G4AdjointCSManager::ComputeAdjointCS(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), SampleAdjSecEnergyFromCSMatrix(), SampleAdjSecEnergyFromDiffCrossSectionPerAtom(), and G4AdjointeIonisationModel::SampleSecondaries().

00658 { G4double maxEProj= HighEnergyLimit;
00659   if (second_part_of_same_type)  maxEProj=std::min(kinEnergyScatProj*2.,HighEnergyLimit);
00660   return maxEProj;
00661 }

G4double G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProjCase ( G4double PrimAdjEnergy ) [virtual]

Reimplemented in G4AdjointComptonModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 676 of file G4VEmAdjointModel.cc.

References second_part_of_same_type.

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), ComputeAdjointCrossSectionVectorPerAtomForSecond(), ComputeAdjointCrossSectionVectorPerVolumeForSecond(), G4AdjointCSManager::ComputeAdjointCS(), DiffCrossSectionPerAtomPrimToSecond(), G4AdjointeIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerVolumePrimToSecond(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated1(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), SampleAdjSecEnergyFromCSMatrix(), SampleAdjSecEnergyFromDiffCrossSectionPerAtom(), and G4AdjointeIonisationModel::SampleSecondaries().

00677 { G4double minEProj=PrimAdjEnergy;
00678   if (second_part_of_same_type)  minEProj=PrimAdjEnergy*2.;
00679   return minEProj;
00680 }

G4double G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProjCase	(	G4double	PrimAdjEnergy,
		G4double	Tcut = `0`
	)			`[virtual]`

Reimplemented in G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 664 of file G4VEmAdjointModel.cc.

References ApplyCutInRange.

00665 { G4double Emin=PrimAdjEnergy;
00666   if (ApplyCutInRange) Emin=PrimAdjEnergy+Tcut;
00667   return Emin;
00668 }

G4bool G4VEmAdjointModel::GetSecondPartOfSameType ( ) [inline]

Definition at line 203 of file G4VEmAdjointModel.hh.

References second_part_of_same_type.

00203 {return second_part_of_same_type;}

G4bool G4VEmAdjointModel::GetUseMatrix ( ) [inline]

Definition at line 211 of file G4VEmAdjointModel.hh.

References UseMatrix.

Referenced by G4AdjointCSManager::ComputeAdjointCS().

00211 {return UseMatrix;}

G4bool G4VEmAdjointModel::GetUseMatrixPerElement ( ) [inline]

Definition at line 212 of file G4VEmAdjointModel.hh.

References UseMatrixPerElement.

Referenced by G4AdjointCSManager::ComputeAdjointCS().

00212 { return UseMatrixPerElement;}

G4bool G4VEmAdjointModel::GetUseOnlyOneMatrixForAllElements ( ) [inline]

Definition at line 213 of file G4VEmAdjointModel.hh.

References UseOnlyOneMatrixForAllElements.

Referenced by G4AdjointCSManager::ComputeAdjointCS().

00213 { return UseOnlyOneMatrixForAllElements;}

G4double G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix	(	G4double	prim_energy,
		G4bool	IsScatProjToProjCase
	)			`[protected]`

Definition at line 544 of file G4VEmAdjointModel.cc.

References indexOfUsedCrossSectionMatrix, SampleAdjSecEnergyFromCSMatrix(), and SelectCSMatrix().

00545 { SelectCSMatrix(IsScatProjToProjCase);
00546   return SampleAdjSecEnergyFromCSMatrix(indexOfUsedCrossSectionMatrix, aPrimEnergy, IsScatProjToProjCase);
00547 }

G4double G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix	(	size_t	MatrixIndex,
		G4double	prim_energy,
		G4bool	IsScatProjToProjCase
	)			`[protected]`

Definition at line 454 of file G4VEmAdjointModel.cc.

References ApplyCutInRange, currentTcutForDirectSecond, G4AdjointInterpolator::FindPositionForLogVector(), G4cout, G4endl, G4UniformRand, G4AdjointCSMatrix::GetData(), G4AdjointInterpolator::GetInstance(), G4AdjointCSMatrix::GetLogPrimEnergyVector(), GetSecondAdjEnergyMaxForProdToProjCase(), GetSecondAdjEnergyMaxForScatProjToProjCase(), GetSecondAdjEnergyMinForProdToProjCase(), GetSecondAdjEnergyMinForScatProjToProjCase(), G4AdjointInterpolator::Interpolate(), G4AdjointInterpolator::InterpolateForLogVector(), G4AdjointCSMatrix::IsScatProjToProjCase(), G4AdjointInterpolator::LinearInterpolation(), and second_part_of_same_type.

Referenced by SampleAdjSecEnergyFromCSMatrix(), G4AdjointIonIonisationModel::SampleSecondaries(), G4AdjointhIonisationModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), and G4AdjointBremsstrahlungModel::SampleSecondaries().

00455 { 
00456   
00457   
00458   G4AdjointCSMatrix* theMatrix= (*pOnCSMatrixForProdToProjBackwardScattering)[MatrixIndex];
00459   if (IsScatProjToProjCase) theMatrix= (*pOnCSMatrixForScatProjToProjBackwardScattering)[MatrixIndex];
00460   std::vector< double>* theLogPrimEnergyVector = theMatrix->GetLogPrimEnergyVector();
00461   
00462   if (theLogPrimEnergyVector->size() ==0){
00463         G4cout<<"No data are contained in the given AdjointCSMatrix!"<<G4endl;
00464         G4cout<<"The sampling procedure will be stopped."<<G4endl;
00465         return 0.;
00466         
00467   }
00468   
00469   G4AdjointInterpolator* theInterpolator=G4AdjointInterpolator::GetInstance();
00470   G4double aLogPrimEnergy = std::log(aPrimEnergy);
00471   size_t ind =theInterpolator->FindPositionForLogVector(aLogPrimEnergy,*theLogPrimEnergyVector);
00472   
00473   
00474   G4double aLogPrimEnergy1,aLogPrimEnergy2;
00475   G4double aLogCS1,aLogCS2;
00476   G4double log01,log02;
00477   std::vector< double>* aLogSecondEnergyVector1 =0;
00478   std::vector< double>* aLogSecondEnergyVector2  =0;
00479   std::vector< double>* aLogProbVector1=0;
00480   std::vector< double>* aLogProbVector2=0; 
00481   std::vector< size_t>* aLogProbVectorIndex1=0;
00482   std::vector< size_t>* aLogProbVectorIndex2=0;
00483                                                                      
00484   theMatrix->GetData(ind, aLogPrimEnergy1,aLogCS1,log01, aLogSecondEnergyVector1,aLogProbVector1,aLogProbVectorIndex1);
00485   theMatrix->GetData(ind+1, aLogPrimEnergy2,aLogCS2,log02, aLogSecondEnergyVector2,aLogProbVector2,aLogProbVectorIndex2);
00486   
00487   G4double rand_var = G4UniformRand();
00488   G4double log_rand_var= std::log(rand_var);
00489   G4double log_Tcut =std::log(currentTcutForDirectSecond);
00490   G4double Esec=0;
00491   G4double log_dE1,log_dE2;
00492   G4double log_rand_var1,log_rand_var2;
00493   G4double log_E1,log_E2;
00494   log_rand_var1=log_rand_var;
00495   log_rand_var2=log_rand_var;
00496   
00497   G4double Emin=0.;
00498   G4double Emax=0.;
00499   if (theMatrix->IsScatProjToProjCase()){ //case where Tcut plays a role
00500         Emin=GetSecondAdjEnergyMinForScatProjToProjCase(aPrimEnergy,currentTcutForDirectSecond);
00501         Emax=GetSecondAdjEnergyMaxForScatProjToProjCase(aPrimEnergy);
00502         G4double dE=0;
00503         if (Emin < Emax ){
00504             if (ApplyCutInRange) {
00505                 if (second_part_of_same_type && currentTcutForDirectSecond>aPrimEnergy) return aPrimEnergy;
00506                 
00507                 log_rand_var1=log_rand_var+theInterpolator->InterpolateForLogVector(log_Tcut,*aLogSecondEnergyVector1,*aLogProbVector1);
00508                 log_rand_var2=log_rand_var+theInterpolator->InterpolateForLogVector(log_Tcut,*aLogSecondEnergyVector2,*aLogProbVector2);
00509                 
00510             }   
00511             log_dE1 = theInterpolator->Interpolate(log_rand_var1,*aLogProbVector1,*aLogSecondEnergyVector1,"Lin");
00512             log_dE2 = theInterpolator->Interpolate(log_rand_var2,*aLogProbVector2,*aLogSecondEnergyVector2,"Lin");
00513              dE=std::exp(theInterpolator->LinearInterpolation(aLogPrimEnergy,aLogPrimEnergy1,aLogPrimEnergy2,log_dE1,log_dE2));
00514         }
00515         
00516         Esec = aPrimEnergy +dE;
00517         Esec=std::max(Esec,Emin);
00518         Esec=std::min(Esec,Emax);
00519         
00520   }
00521   else { //Tcut condition is already full-filled
00522         
00523         log_E1 = theInterpolator->Interpolate(log_rand_var,*aLogProbVector1,*aLogSecondEnergyVector1,"Lin");
00524         log_E2 = theInterpolator->Interpolate(log_rand_var,*aLogProbVector2,*aLogSecondEnergyVector2,"Lin");
00525         
00526         Esec = std::exp(theInterpolator->LinearInterpolation(aLogPrimEnergy,aLogPrimEnergy1,aLogPrimEnergy2,log_E1,log_E2));
00527         Emin=GetSecondAdjEnergyMinForProdToProjCase(aPrimEnergy);
00528         Emax=GetSecondAdjEnergyMaxForProdToProjCase(aPrimEnergy);
00529         Esec=std::max(Esec,Emin);
00530         Esec=std::min(Esec,Emax);
00531         
00532   }
00533         
00534   return Esec;
00535   
00536   
00537   
00538  
00539                                                                                    
00540 }

G4double G4VEmAdjointModel::SampleAdjSecEnergyFromDiffCrossSectionPerAtom	(	G4double	prim_energy,
		G4bool	IsScatProjToProjCase
	)			`[protected, virtual]`

Definition at line 576 of file G4VEmAdjointModel.cc.

References currentTcutForDirectSecond, DiffCrossSectionPerAtomPrimToScatPrim(), DiffCrossSectionPerAtomPrimToSecond(), G4UniformRand, GetSecondAdjEnergyMaxForProdToProjCase(), GetSecondAdjEnergyMaxForScatProjToProjCase(), and GetSecondAdjEnergyMinForProdToProjCase().

00577 {  
00578   // here we try to use the rejection method 
00579   //-----------------------------------------
00580   
00581   G4double E=0;
00582   G4double x,xmin,greject,q;
00583   if ( IsScatProjToProjCase){
00584         G4double Emax = GetSecondAdjEnergyMaxForScatProjToProjCase(prim_energy);
00585         G4double Emin= prim_energy+currentTcutForDirectSecond;
00586         xmin=Emin/Emax;
00587         G4double grejmax = DiffCrossSectionPerAtomPrimToScatPrim(Emin,prim_energy,1)*prim_energy; 
00588 
00589         do {
00590                 q = G4UniformRand();
00591                 x = 1./(q*(1./xmin -1.) +1.);
00592                 E=x*Emax;
00593                 greject = DiffCrossSectionPerAtomPrimToScatPrim( E,prim_energy ,1)*prim_energy; 
00594                 
00595         }       
00596         
00597         while( greject < G4UniformRand()*grejmax );     
00598         
00599   }
00600   else {
00601         G4double Emax = GetSecondAdjEnergyMaxForProdToProjCase(prim_energy);
00602         G4double Emin=  GetSecondAdjEnergyMinForProdToProjCase(prim_energy);;
00603         xmin=Emin/Emax;
00604         G4double grejmax = DiffCrossSectionPerAtomPrimToSecond(Emin,prim_energy,1); 
00605         do {
00606                 q = G4UniformRand();
00607                 x = std::pow(xmin, q);
00608                 E=x*Emax;
00609                 greject = DiffCrossSectionPerAtomPrimToSecond( E,prim_energy ,1); 
00610                 
00611         }       
00612         
00613         while( greject < G4UniformRand()*grejmax );
00614   
00615   
00616   
00617   }
00618   
00619   return E;
00620 }

virtual void G4VEmAdjointModel::SampleSecondaries	(	const G4Track &	aTrack,
		G4bool	IsScatProjToProjCase,
		G4ParticleChange *	fParticleChange
	)			`[pure virtual]`

Implemented in G4AdjointBremsstrahlungModel, G4AdjointComptonModel, G4AdjointeIonisationModel, G4AdjointhIonisationModel, G4AdjointIonIonisationModel, and G4AdjointPhotoElectricModel.

Referenced by G4VAdjointReverseReaction::PostStepDoIt().

void G4VEmAdjointModel::SelectCSMatrix ( G4bool IsScatProjToProjCase ) [protected]

Definition at line 550 of file G4VEmAdjointModel.cc.

References CS_Vs_ElementForProdToProjCase, CS_Vs_ElementForScatProjToProjCase, currentMaterial, currentMaterialIndex, G4UniformRand, G4Material::GetElement(), G4Element::GetIndex(), indexOfUsedCrossSectionMatrix, lastAdjointCSForProdToProjCase, lastAdjointCSForScatProjToProjCase, lastCS, UseMatrixPerElement, and UseOnlyOneMatrixForAllElements.

Referenced by SampleAdjSecEnergyFromCSMatrix().

00551 { 
00552   indexOfUsedCrossSectionMatrix=0;
00553   if (!UseMatrixPerElement) indexOfUsedCrossSectionMatrix = currentMaterialIndex;
00554   else if (!UseOnlyOneMatrixForAllElements) { //Select Material
00555         std::vector<G4double>* CS_Vs_Element = &CS_Vs_ElementForScatProjToProjCase;
00556         lastCS=lastAdjointCSForScatProjToProjCase;
00557         if ( !IsScatProjToProjCase) {
00558                 CS_Vs_Element = &CS_Vs_ElementForProdToProjCase;
00559                 lastCS=lastAdjointCSForProdToProjCase;
00560         }       
00561         G4double rand_var= G4UniformRand();
00562         G4double SumCS=0.;
00563         size_t ind=0;
00564         for (size_t i=0;i<CS_Vs_Element->size();i++){
00565                 SumCS+=(*CS_Vs_Element)[i];
00566                 if (rand_var<=SumCS/lastCS){
00567                         ind=i;
00568                         break;
00569                 }
00570         }
00571         indexOfUsedCrossSectionMatrix = currentMaterial->GetElement(ind)->GetIndex();
00572   }
00573 }

void G4VEmAdjointModel::SetAdjointEquivalentOfDirectPrimaryParticleDefinition ( G4ParticleDefinition * aPart )

Definition at line 719 of file G4VEmAdjointModel.cc.

References G4Electron::Electron(), G4Gamma::Gamma(), G4ParticleDefinition::GetParticleName(), theAdjEquivOfDirectPrimPartDef, and theDirectPrimaryPartDef.

00720 {
00721   theAdjEquivOfDirectPrimPartDef=aPart;
00722   if (theAdjEquivOfDirectPrimPartDef->GetParticleName() =="adj_e-")
00723                                         theDirectPrimaryPartDef=G4Electron::Electron();
00724   if (theAdjEquivOfDirectPrimPartDef->GetParticleName() =="adj_gamma")
00725                                         theDirectPrimaryPartDef=G4Gamma::Gamma();
00726 }

void G4VEmAdjointModel::SetAdjointEquivalentOfDirectSecondaryParticleDefinition ( G4ParticleDefinition * aPart ) [inline]

Definition at line 197 of file G4VEmAdjointModel.hh.

References theAdjEquivOfDirectSecondPartDef.

00197                                                                                                   {
00198         theAdjEquivOfDirectSecondPartDef =aPart;
00199   }

void G4VEmAdjointModel::SetApplyCutInRange ( G4bool aBool ) [inline]

Definition at line 210 of file G4VEmAdjointModel.hh.

References ApplyCutInRange.

Referenced by G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), and G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel().

00210 { ApplyCutInRange = aBool;}

virtual void G4VEmAdjointModel::SetCSBiasingFactor ( G4double aVal ) [inline, virtual]

Definition at line 217 of file G4VEmAdjointModel.hh.

References CS_biasing_factor.

00217 {CS_biasing_factor = aVal;}

void G4VEmAdjointModel::SetCSMatrices	(	std::vector< G4AdjointCSMatrix * > *	Vec1CSMatrix,
		std::vector< G4AdjointCSMatrix * > *	Vec2CSMatrix
	)			`[inline]`

Definition at line 174 of file G4VEmAdjointModel.hh.

References pOnCSMatrixForProdToProjBackwardScattering, and pOnCSMatrixForScatProjToProjBackwardScattering.

00174                                                                                                                          {
00175                                  pOnCSMatrixForProdToProjBackwardScattering = Vec1CSMatrix;
00176                                  pOnCSMatrixForScatProjToProjBackwardScattering = Vec2CSMatrix;
00177                                  
00178         
00179   };

void G4VEmAdjointModel::SetHighEnergyLimit ( G4double aVal )

Definition at line 706 of file G4VEmAdjointModel.cc.

References HighEnergyLimit, G4VEmModel::SetHighEnergyLimit(), and theDirectEMModel.

00707 { HighEnergyLimit=aVal;
00708   if (theDirectEMModel) theDirectEMModel->SetHighEnergyLimit( aVal);
00709 }

void G4VEmAdjointModel::SetLowEnergyLimit ( G4double aVal )

Definition at line 712 of file G4VEmAdjointModel.cc.

References LowEnergyLimit, G4VEmModel::SetLowEnergyLimit(), and theDirectEMModel.

00713 {
00714   LowEnergyLimit=aVal;
00715   if (theDirectEMModel) theDirectEMModel->SetLowEnergyLimit( aVal);
00716 }

void G4VEmAdjointModel::SetSecondPartOfSameType ( G4bool aBool ) [inline]

Definition at line 201 of file G4VEmAdjointModel.hh.

References second_part_of_same_type.

Referenced by G4eInverseBremsstrahlung::G4eInverseBremsstrahlung(), G4eInverseCompton::G4eInverseCompton(), G4eInverseIonisation::G4eInverseIonisation(), G4hInverseIonisation::G4hInverseIonisation(), G4InversePEEffect::G4InversePEEffect(), and G4IonInverseIonisation::G4IonInverseIonisation().

00201 {second_part_of_same_type =aBool;}

void G4VEmAdjointModel::SetUseMatrix ( G4bool aBool ) [inline]

Definition at line 205 of file G4VEmAdjointModel.hh.

References UseMatrix.

Referenced by G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), and G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel().

00205 { UseMatrix = aBool;}

void G4VEmAdjointModel::SetUseMatrixPerElement ( G4bool aBool ) [inline]

Definition at line 207 of file G4VEmAdjointModel.hh.

References UseMatrixPerElement.

Referenced by G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), and G4AdjointComptonModel::G4AdjointComptonModel().

00207 { UseMatrixPerElement = aBool;}

void G4VEmAdjointModel::SetUseOnlyOneMatrixForAllElements ( G4bool aBool ) [inline]

Definition at line 208 of file G4VEmAdjointModel.hh.

References UseOnlyOneMatrixForAllElements.

Referenced by G4AdjointComptonModel::G4AdjointComptonModel().

00208 { UseOnlyOneMatrixForAllElements = aBool;}

Field Documentation

G4bool G4VEmAdjointModel::ApplyCutInRange [protected]

Definition at line 314 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), GetApplyCutInRange(), GetSecondAdjEnergyMinForScatProjToProjCase(), SampleAdjSecEnergyFromCSMatrix(), and SetApplyCutInRange().

G4int G4VEmAdjointModel::ASelectedNucleus [protected]

Definition at line 269 of file G4VEmAdjointModel.hh.

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), ComputeAdjointCrossSectionVectorPerAtomForSecond(), DiffCrossSectionFunction1(), and DiffCrossSectionFunction2().

G4double G4VEmAdjointModel::CS_biasing_factor [protected]

Definition at line 335 of file G4VEmAdjointModel.hh.

Referenced by CorrectPostStepWeight(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), DiffCrossSectionFunction1(), DiffCrossSectionFunction2(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), and SetCSBiasingFactor().

std::vector<G4double> G4VEmAdjointModel::CS_Vs_ElementForProdToProjCase [protected]

Definition at line 284 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), and SelectCSMatrix().

std::vector<G4double> G4VEmAdjointModel::CS_Vs_ElementForScatProjToProjCase [protected]

Definition at line 283 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), and SelectCSMatrix().

G4MaterialCutsCouple* G4VEmAdjointModel::currentCouple [protected]

Definition at line 309 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointPhotoElectricModel::AdjointCrossSection(), CorrectPostStepWeight(), DefineCurrentMaterial(), G4VEmAdjointModel(), and G4AdjointComptonModel::RapidSampleSecondaries().

size_t G4VEmAdjointModel::currentCoupleIndex [protected]

Definition at line 311 of file G4VEmAdjointModel.hh.

Referenced by DefineCurrentMaterial().

G4Material* G4VEmAdjointModel::currentMaterial [protected]

Definition at line 308 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), G4AdjointPhotoElectricModel::AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), G4AdjointComptonModel::AdjointCrossSection(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), DefineCurrentMaterial(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointPhotoElectricModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), and SelectCSMatrix().

size_t G4VEmAdjointModel::currentMaterialIndex [protected]

Definition at line 310 of file G4VEmAdjointModel.hh.

Referenced by DefineCurrentMaterial(), and SelectCSMatrix().

G4double G4VEmAdjointModel::currentTcutForDirectPrim [protected]

Definition at line 312 of file G4VEmAdjointModel.hh.

G4double G4VEmAdjointModel::currentTcutForDirectSecond [protected]

Definition at line 313 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), DefineCurrentMaterial(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), SampleAdjSecEnergyFromCSMatrix(), SampleAdjSecEnergyFromDiffCrossSectionPerAtom(), and G4AdjointeIonisationModel::SampleSecondaries().

G4double G4VEmAdjointModel::HighEnergyLimit [protected]

Definition at line 328 of file G4VEmAdjointModel.hh.

size_t G4VEmAdjointModel::indexOfUsedCrossSectionMatrix [protected]

Definition at line 347 of file G4VEmAdjointModel.hh.

Referenced by SampleAdjSecEnergyFromCSMatrix(), and SelectCSMatrix().

G4double G4VEmAdjointModel::kinEnergyProdForIntegration [protected]

Definition at line 272 of file G4VEmAdjointModel.hh.

Referenced by ComputeAdjointCrossSectionVectorPerAtomForSecond(), ComputeAdjointCrossSectionVectorPerVolumeForSecond(), and DiffCrossSectionFunction1().

G4double G4VEmAdjointModel::kinEnergyProjForIntegration [protected]

Definition at line 274 of file G4VEmAdjointModel.hh.

Referenced by DiffCrossSectionPerVolumeFunctionForIntegrationOverEkinProj().

G4double G4VEmAdjointModel::kinEnergyScatProjForIntegration [protected]

Definition at line 273 of file G4VEmAdjointModel.hh.

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), and DiffCrossSectionFunction2().

G4double G4VEmAdjointModel::lastAdjointCSForProdToProjCase [protected]

Definition at line 288 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), CorrectPostStepWeight(), G4AdjointeIonisationModel::SampleSecondaries(), and SelectCSMatrix().

G4double G4VEmAdjointModel::lastAdjointCSForScatProjToProjCase [protected]

Definition at line 287 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), CorrectPostStepWeight(), G4AdjointeIonisationModel::SampleSecondaries(), and SelectCSMatrix().

G4double G4VEmAdjointModel::lastCS [protected]

Definition at line 286 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), G4AdjointPhotoElectricModel::AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), G4AdjointComptonModel::AdjointCrossSection(), CorrectPostStepWeight(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), and SelectCSMatrix().

G4double G4VEmAdjointModel::LowEnergyLimit [protected]

Definition at line 329 of file G4VEmAdjointModel.hh.

Referenced by GetLowEnergyLimit(), and SetLowEnergyLimit().

G4double G4VEmAdjointModel::mass_ratio_product [protected]

Definition at line 321 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel().

G4double G4VEmAdjointModel::mass_ratio_projectile [protected]

Definition at line 322 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel().

size_t G4VEmAdjointModel::model_index [protected]

Definition at line 349 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel().

const G4String G4VEmAdjointModel::name [protected]

Definition at line 264 of file G4VEmAdjointModel.hh.

Referenced by GetName().

std::vector< G4AdjointCSMatrix* >* G4VEmAdjointModel::pOnCSMatrixForProdToProjBackwardScattering [protected]

Definition at line 281 of file G4VEmAdjointModel.hh.

Referenced by SetCSMatrices().

std::vector< G4AdjointCSMatrix* >* G4VEmAdjointModel::pOnCSMatrixForScatProjToProjBackwardScattering [protected]

Definition at line 282 of file G4VEmAdjointModel.hh.

Referenced by SetCSMatrices().

G4VParticleChange* G4VEmAdjointModel::pParticleChange [protected]

Definition at line 256 of file G4VEmAdjointModel.hh.

G4double G4VEmAdjointModel::preStepEnergy [protected]

Definition at line 304 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), and CorrectPostStepWeight().

G4bool G4VEmAdjointModel::second_part_of_same_type [protected]

Definition at line 299 of file G4VEmAdjointModel.hh.

G4Material* G4VEmAdjointModel::SelectedMaterial [protected]

Definition at line 271 of file G4VEmAdjointModel.hh.

Referenced by ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), ComputeAdjointCrossSectionVectorPerVolumeForSecond(), DiffCrossSectionFunction1(), DiffCrossSectionFunction2(), and DiffCrossSectionPerVolumeFunctionForIntegrationOverEkinProj().

G4ParticleDefinition* G4VEmAdjointModel::theAdjEquivOfDirectPrimPartDef [protected]

Definition at line 296 of file G4VEmAdjointModel.hh.

G4ParticleDefinition* G4VEmAdjointModel::theAdjEquivOfDirectSecondPartDef [protected]

Definition at line 297 of file G4VEmAdjointModel.hh.

Referenced by DefineCurrentMaterial(), G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), GetAdjointEquivalentOfDirectSecondaryParticleDefinition(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointIonIonisationModel::SampleSecondaries(), G4AdjointhIonisationModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), and SetAdjointEquivalentOfDirectSecondaryParticleDefinition().

G4VEmModel* G4VEmAdjointModel::theDirectEMModel [protected]

Definition at line 255 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), DefineDirectEMModel(), G4AdjointComptonModel::DiffCrossSectionPerAtomPrimToScatPrim(), DiffCrossSectionPerAtomPrimToSecond(), G4AdjointIonIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointhIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerVolumePrimToSecond(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated1(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated2(), G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4VEmAdjointModel(), G4AdjointBremsstrahlungModel::GetAdjointCrossSection(), SetHighEnergyLimit(), and SetLowEnergyLimit().

G4ParticleDefinition* G4VEmAdjointModel::theDirectPrimaryPartDef [protected]

Definition at line 298 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), DiffCrossSectionPerAtomPrimToSecond(), G4AdjointIonIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointhIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerVolumePrimToSecond(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated1(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated2(), G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), G4AdjointBremsstrahlungModel::GetAdjointCrossSection(), SetAdjointEquivalentOfDirectPrimaryParticleDefinition(), and G4AdjointIonIonisationModel::SetIon().

G4bool G4VEmAdjointModel::UseMatrix [protected]

Definition at line 340 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointhIonisationModel::AdjointCrossSection(), G4AdjointComptonModel::AdjointCrossSection(), G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), GetUseMatrix(), G4AdjointhIonisationModel::SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), G4AdjointBremsstrahlungModel::SampleSecondaries(), and SetUseMatrix().

G4bool G4VEmAdjointModel::UseMatrixPerElement [protected]

Definition at line 341 of file G4VEmAdjointModel.hh.

Referenced by DiffCrossSectionFunction1(), DiffCrossSectionFunction2(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), GetUseMatrixPerElement(), SelectCSMatrix(), and SetUseMatrixPerElement().

G4bool G4VEmAdjointModel::UseOnlyOneMatrixForAllElements [protected]

Definition at line 342 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), GetUseOnlyOneMatrixForAllElements(), SelectCSMatrix(), and SetUseOnlyOneMatrixForAllElements().

G4int G4VEmAdjointModel::ZSelectedNucleus [protected]

Definition at line 270 of file G4VEmAdjointModel.hh.

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), ComputeAdjointCrossSectionVectorPerAtomForSecond(), DiffCrossSectionFunction1(), and DiffCrossSectionFunction2().

The documentation for this class was generated from the following files:

Generated on Mon May 27 17:53:41 2013 for Geant4 by

1.4.7

G4VEmAdjointModel Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation