G4AdjointCSManager Class Reference

#include <G4AdjointCSManager.hh>

Collaboration diagram for G4AdjointCSManager:

Public Member Functions
	~G4AdjointCSManager ()
G4int	GetNbProcesses ()
size_t	RegisterEmAdjointModel (G4VEmAdjointModel *)
void	RegisterEmProcess (G4VEmProcess *aProcess, G4ParticleDefinition *aPartDef)
void	RegisterEnergyLossProcess (G4VEnergyLossProcess *aProcess, G4ParticleDefinition *aPartDef)
void	RegisterAdjointParticle (G4ParticleDefinition *aPartDef)
void	BuildCrossSectionMatrices ()
void	BuildTotalSigmaTables ()
G4double	GetTotalAdjointCS (G4ParticleDefinition *aPartDef, G4double Ekin, const G4MaterialCutsCouple *aCouple)
G4double	GetTotalForwardCS (G4ParticleDefinition *aPartDef, G4double Ekin, const G4MaterialCutsCouple *aCouple)
G4double	GetAdjointSigma (G4double Ekin_nuc, size_t index_model, G4bool is_scat_proj_to_proj, const G4MaterialCutsCouple *aCouple)
void	GetEminForTotalCS (G4ParticleDefinition *aPartDef, const G4MaterialCutsCouple *aCouple, G4double &emin_adj, G4double &emin_fwd)
void	GetMaxFwdTotalCS (G4ParticleDefinition *aPartDef, const G4MaterialCutsCouple *aCouple, G4double &e_sigma_max, G4double &sigma_max)
void	GetMaxAdjTotalCS (G4ParticleDefinition *aPartDef, const G4MaterialCutsCouple *aCouple, G4double &e_sigma_max, G4double &sigma_max)
G4double	GetCrossSectionCorrection (G4ParticleDefinition *aPartDef, G4double PreStepEkin, const G4MaterialCutsCouple *aCouple, G4bool &fwd_is_used, G4double &fwd_TotCS)
void	SetFwdCrossSectionMode (G4bool aBool)
G4double	GetContinuousWeightCorrection (G4ParticleDefinition *aPartDef, G4double PreStepEkin, G4double AfterStepEkin, const G4MaterialCutsCouple *aCouple, G4double step_length)
G4double	GetPostStepWeightCorrection ()
G4double	ComputeAdjointCS (G4Material *aMaterial, G4VEmAdjointModel *aModel, G4double PrimEnergy, G4double Tcut, G4bool IsScatProjToProjCase, std::vector< G4double > &AdjointCS_for_each_element)
G4Element *	SampleElementFromCSMatrices (G4Material *aMaterial, G4VEmAdjointModel *aModel, G4double PrimEnergy, G4double Tcut, G4bool IsScatProjToProjCase)
G4double	ComputeTotalAdjointCS (const G4MaterialCutsCouple *aMatCutCouple, G4ParticleDefinition *aPart, G4double PrimEnergy)
G4ParticleDefinition *	GetAdjointParticleEquivalent (G4ParticleDefinition *theFwdPartDef)
G4ParticleDefinition *	GetForwardParticleEquivalent (G4ParticleDefinition *theAdjPartDef)
void	SetTmin (G4double aVal)
void	SetTmax (G4double aVal)
void	SetNbins (G4int aInt)
void	SetIon (G4ParticleDefinition *adjIon, G4ParticleDefinition *fwdIon)

Static Public Member Functions
static G4AdjointCSManager *	GetAdjointCSManager ()

Private Member Functions
std::vector< G4AdjointCSMatrix * >	BuildCrossSectionsMatricesForAGivenModelAndElement (G4VEmAdjointModel *aModel, G4int Z, G4int A, G4int nbin_pro_decade)
std::vector< G4AdjointCSMatrix * >	BuildCrossSectionsMatricesForAGivenModelAndMaterial (G4VEmAdjointModel *aModel, G4Material *aMaterial, G4int nbin_pro_decade)
	G4AdjointCSManager ()
void	DefineCurrentMaterial (const G4MaterialCutsCouple *couple)
void	DefineCurrentParticle (const G4ParticleDefinition *aPartDef)
G4double	ComputeAdjointCS (G4double aPrimEnergy, G4AdjointCSMatrix *anAdjointCSMatrix, G4double Tcut)

Private Attributes
std::vector< std::vector< G4AdjointCSMatrix * > >	theAdjointCSMatricesForScatProjToProj
std::vector< std::vector< G4AdjointCSMatrix * > >	theAdjointCSMatricesForProdToProj
std::vector< G4VEmAdjointModel * >	listOfAdjointEMModel
G4Material *	lastMaterial
G4double	lastPrimaryEnergy
G4double	lastTcut
std::vector< size_t >	listOfIndexOfAdjointEMModelInAction
std::vector< G4bool >	listOfIsScatProjToProjCase
std::vector< std::vector< G4double > >	lastAdjointCSVsModelsAndElements
G4bool	CrossSectionMatrixesAreBuilt
size_t	currentParticleIndex
G4ParticleDefinition *	currentParticleDef
std::vector< G4PhysicsTable * >	theTotalForwardSigmaTableVector
std::vector< G4PhysicsTable * >	theTotalAdjointSigmaTableVector
std::vector< std::vector< G4double > >	EminForFwdSigmaTables
std::vector< std::vector< G4double > >	EminForAdjSigmaTables
std::vector< std::vector< G4double > >	EkinofFwdSigmaMax
std::vector< std::vector< G4double > >	EkinofAdjSigmaMax
G4bool	TotalSigmaTableAreBuilt
std::vector< G4PhysicsTable * >	listSigmaTableForAdjointModelScatProjToProj
std::vector< G4PhysicsTable * >	listSigmaTableForAdjointModelProdToProj
std::vector< std::vector< G4VEmProcess * > *>	listOfForwardEmProcess
std::vector< std::vector< G4VEnergyLossProcess * > *>	listOfForwardEnergyLossProcess
std::vector< G4ParticleDefinition * >	theListOfAdjointParticlesInAction
G4double	Tmin
G4double	Tmax
G4int	nbins
G4MaterialCutsCouple *	currentCouple
G4Material *	currentMaterial
size_t	currentMatIndex
G4int	verbose
G4bool	forward_CS_is_used
G4bool	forward_CS_mode
G4double	PreadjCS
G4double	PostadjCS
G4double	PrefwdCS
G4double	PostfwdCS
G4double	LastEkinForCS
G4double	LastCSCorrectionFactor
G4ParticleDefinition *	lastPartDefForCS
G4ParticleDefinition *	theAdjIon
G4ParticleDefinition *	theFwdIon
G4double	massRatio
size_t	eindex

Static Private Attributes
static G4ThreadLocal G4AdjointCSManager *	theInstance = nullptr

Friends
class	G4ThreadLocalSingleton< G4AdjointCSManager >

Detailed Description

Definition at line 69 of file G4AdjointCSManager.hh.

Constructor & Destructor Documentation

~G4AdjointCSManager()

G4AdjointCSManager::~G4AdjointCSManager

(

)

Definition at line 118 of file G4AdjointCSManager.cc.

{;
}

G4AdjointCSManager()

G4AdjointCSManager::G4AdjointCSManager ( )

private

Definition at line 72 of file G4AdjointCSManager.cc.

{ CrossSectionMatrixesAreBuilt=false;
  TotalSigmaTableAreBuilt=false;
  theTotalForwardSigmaTableVector.clear();
  theTotalAdjointSigmaTableVector.clear();
  listOfForwardEmProcess.clear();
  listOfForwardEnergyLossProcess.clear();
  theListOfAdjointParticlesInAction.clear(); 
  EminForFwdSigmaTables.clear();
  EminForAdjSigmaTables.clear();
  EkinofFwdSigmaMax.clear();
  EkinofAdjSigmaMax.clear();
  listSigmaTableForAdjointModelScatProjToProj.clear();
  listSigmaTableForAdjointModelProdToProj.clear();
  Tmin=0.1*keV;
  Tmax=100.*TeV;
  nbins=320; //probably this should be decrease, that was choosen to avoid error in the CS value closed to CS jump.(For example at Tcut)
  
  RegisterAdjointParticle(G4AdjointElectron::AdjointElectron());
  RegisterAdjointParticle(G4AdjointGamma::AdjointGamma());
  RegisterAdjointParticle(G4AdjointProton::AdjointProton());
  
  verbose  = 1;
  currentParticleIndex = 0;
  currentMatIndex = 0;
  eindex = 0;
 
  lastPartDefForCS = nullptr;
  LastEkinForCS = lastPrimaryEnergy = lastTcut = 0.;
  LastCSCorrectionFactor = massRatio = 1.;
  
  forward_CS_is_used = true;
  forward_CS_mode = true;
  
  currentParticleDef = nullptr;
  currentCouple =nullptr;
  currentMaterial=nullptr;
  lastMaterial=nullptr;

  theAdjIon = nullptr;
  theFwdIon = nullptr;
 
  PreadjCS = PostadjCS = PrefwdCS = PostfwdCS = 0.0;
}

Here is the call graph for this function:

Member Function Documentation

BuildCrossSectionMatrices()

void G4AdjointCSManager::BuildCrossSectionMatrices

(

)

Definition at line 182 of file G4AdjointCSManager.cc.

{   
    if (CrossSectionMatrixesAreBuilt) return;
        //Tcut, Tmax 
            //The matrices will be computed probably just once
              //When Tcut will change some PhysicsTable will be recomputed  
              // for each MaterialCutCouple but not all the matrices    
              //The Tcut defines a lower limit in the energy of the Projectile before the scattering
              //In the Projectile to Scattered Projectile case we have
              //            E_ScatProj<E_Proj-Tcut
              //Therefore in the adjoint case we have
              //            Eproj> E_ScatProj+Tcut
              //This implies that when computing the adjoint CS we should integrate over Epro
              // from E_ScatProj+Tcut to Emax
              //In the Projectile to Secondary case Tcut plays a role only in the fact that  
              // Esecond should be greater than Tcut to have the possibility to have any adjoint
              //process          
              //To avoid to recompute the matrices for all changes of MaterialCutCouple
              //We propose to compute the matrices only once for the minimum possible Tcut and then
              //to interpolate the probability for a new Tcut (implemented in G4VAdjointEmModel)
    
    
    theAdjointCSMatricesForScatProjToProj.clear();
    theAdjointCSMatricesForProdToProj.clear();
    const G4ElementTable* theElementTable = G4Element::GetElementTable();
    const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
    
    G4cout<<"========== Computation of cross section matrices for adjoint models =========="<<G4endl;
    for (size_t i=0; i<listOfAdjointEMModel.size();i++){
        G4VEmAdjointModel* aModel =listOfAdjointEMModel[i];
        G4cout<<"Build adjoint cross section matrices for "<<aModel->GetName()<<G4endl;
        if (aModel->GetUseMatrix()){
            std::vector<G4AdjointCSMatrix*>* aListOfMat1 = new std::vector<G4AdjointCSMatrix*>();
            std::vector<G4AdjointCSMatrix*>* aListOfMat2 = new std::vector<G4AdjointCSMatrix*>();
            aListOfMat1->clear();
            aListOfMat2->clear();
            if (aModel->GetUseMatrixPerElement()){
                if (aModel->GetUseOnlyOneMatrixForAllElements()){
                        std::vector<G4AdjointCSMatrix*>
                        two_matrices=BuildCrossSectionsMatricesForAGivenModelAndElement(aModel,1, 1, 80);
                        aListOfMat1->push_back(two_matrices[0]);
                        aListOfMat2->push_back(two_matrices[1]);
                }
                else {      
                    for (size_t j=0; j<theElementTable->size();j++){
                        G4Element* anElement=(*theElementTable)[j];
                        G4int Z = G4lrint(anElement->GetZ());
                        G4int A = G4lrint(anElement->GetN());
                        std::vector<G4AdjointCSMatrix*>
                            two_matrices=BuildCrossSectionsMatricesForAGivenModelAndElement(aModel,Z, A, 40);
                        aListOfMat1->push_back(two_matrices[0]);
                        aListOfMat2->push_back(two_matrices[1]);
                    }
                }   
            }
            else { //Per material case
                for (size_t j=0; j<theMaterialTable->size();j++){
                    G4Material* aMaterial=(*theMaterialTable)[j];
                    std::vector<G4AdjointCSMatrix*>
                        two_matrices=BuildCrossSectionsMatricesForAGivenModelAndMaterial(aModel,aMaterial, 40);
                    aListOfMat1->push_back(two_matrices[0]);
                    aListOfMat2->push_back(two_matrices[1]);
                }
            
            }
            theAdjointCSMatricesForProdToProj.push_back(*aListOfMat1);
            theAdjointCSMatricesForScatProjToProj.push_back(*aListOfMat2);  
            aModel->SetCSMatrices(aListOfMat1, aListOfMat2);    
        }
        else {  G4cout<<"The model "<<aModel->GetName()<<" does not use cross section matrices"<<G4endl;
            std::vector<G4AdjointCSMatrix*> two_empty_matrices;
            theAdjointCSMatricesForProdToProj.push_back(two_empty_matrices);
            theAdjointCSMatricesForScatProjToProj.push_back(two_empty_matrices);
            
        }       
    }
    G4cout<<"              All adjoint cross section matrices are computed!"<<G4endl;
    G4cout<<"======================================================================"<<G4endl;
    
    CrossSectionMatrixesAreBuilt = true;


}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildCrossSectionsMatricesForAGivenModelAndElement()

std::vector< G4AdjointCSMatrix * > G4AdjointCSManager::BuildCrossSectionsMatricesForAGivenModelAndElement ( G4VEmAdjointModel *  aModel, G4int  Z, G4int  A, G4int  nbin_pro_decade  )

private

Definition at line 748 of file G4AdjointCSManager.cc.

{ 
  G4AdjointCSMatrix* theCSMatForProdToProjBackwardScattering = new G4AdjointCSMatrix(false);
  G4AdjointCSMatrix* theCSMatForScatProjToProjBackwardScattering = new G4AdjointCSMatrix(true);
 
 
  //make the vector of primary energy of the adjoint particle, could try to make this just once ? 
  
   G4double EkinMin =aModel->GetLowEnergyLimit();
   G4double EkinMaxForScat =aModel->GetHighEnergyLimit()*0.999;
   G4double EkinMaxForProd =aModel->GetHighEnergyLimit()*0.999;
   if (aModel->GetSecondPartOfSameType() )EkinMaxForProd =EkinMaxForProd/2.;
   
    
   //Product to projectile backward scattering
   //-----------------------------------------
   G4double fE=std::pow(10.,1./nbin_pro_decade);
   G4double E2=std::pow(10.,double( int(std::log10(EkinMin)*nbin_pro_decade)+1)/nbin_pro_decade)/fE;
   G4double E1=EkinMin;
   // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
   while (E1 <EkinMaxForProd){
    E1=std::max(EkinMin,E2);
    E1=std::min(EkinMaxForProd,E1);
    std::vector< std::vector< double>* >  aMat= aModel->ComputeAdjointCrossSectionVectorPerAtomForSecond(E1,Z,A,nbin_pro_decade);
    if (aMat.size()>=2) {
        std::vector< double>* log_ESecVec=aMat[0];
        std::vector< double>* log_CSVec=aMat[1];
        G4double log_adjointCS=log_CSVec->back();
        //normalise CSVec such that it becomes a probability vector
        for (size_t j=0;j<log_CSVec->size();j++) {
                if (j==0) (*log_CSVec)[j] = 0.; 
            else (*log_CSVec)[j]=std::log(1.-std::exp((*log_CSVec)[j]-log_adjointCS) +1e-50);
        }   
        (*log_CSVec)[log_CSVec->size()-1]=(*log_CSVec)[log_CSVec->size()-2]-std::log(1000.);
        theCSMatForProdToProjBackwardScattering->AddData(std::log(E1),log_adjointCS,log_ESecVec,log_CSVec,0);
    }   
    E1=E2;
    E2*=fE;
   }
   
   //Scattered projectile to projectile backward scattering
   //-----------------------------------------
   
   E2=std::pow(10.,double( int(std::log10(EkinMin)*nbin_pro_decade)+1)/nbin_pro_decade)/fE;
   E1=EkinMin;
   // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
   while (E1 <EkinMaxForScat){
    E1=std::max(EkinMin,E2);
    E1=std::min(EkinMaxForScat,E1);
    std::vector< std::vector< double>* >  aMat= aModel->ComputeAdjointCrossSectionVectorPerAtomForScatProj(E1,Z,A,nbin_pro_decade);
    if (aMat.size()>=2) {
        std::vector< double>* log_ESecVec=aMat[0];
        std::vector< double>* log_CSVec=aMat[1];
        G4double log_adjointCS=log_CSVec->back();
        //normalise CSVec such that it becomes a probability vector
        for (size_t j=0;j<log_CSVec->size();j++) {
                if (j==0) (*log_CSVec)[j] = 0.; 
            else (*log_CSVec)[j]=std::log(1.-std::exp((*log_CSVec)[j]-log_adjointCS)+1e-50);
        }   
        (*log_CSVec)[log_CSVec->size()-1]=(*log_CSVec)[log_CSVec->size()-2]-std::log(1000.);
        theCSMatForScatProjToProjBackwardScattering->AddData(std::log(E1),log_adjointCS,log_ESecVec,log_CSVec,0);
    }
    E1=E2;
    E2*=fE;
   }
   
   
  std::vector<G4AdjointCSMatrix*> res;
  res.clear();
  res.push_back(theCSMatForProdToProjBackwardScattering);
  res.push_back(theCSMatForScatProjToProjBackwardScattering);
  

/*
  G4String file_name;
  std::stringstream astream;
  G4String str_Z;
  astream<<Z;
  astream>>str_Z;  
  theCSMatForProdToProjBackwardScattering->Write(aModel->GetName()+G4String("_CSMat_Z")+str_Z+"_ProdToProj.txt"); 
  theCSMatForScatProjToProjBackwardScattering->Write(aModel->GetName()+G4String("_CSMat_Z")+str_Z+"_ScatProjToProj.txt");
 
*/

  
  return res;
  
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildCrossSectionsMatricesForAGivenModelAndMaterial()

std::vector< G4AdjointCSMatrix * > G4AdjointCSManager::BuildCrossSectionsMatricesForAGivenModelAndMaterial ( G4VEmAdjointModel *  aModel, G4Material *  aMaterial, G4int  nbin_pro_decade  )

private

Definition at line 841 of file G4AdjointCSManager.cc.

{ 
  G4AdjointCSMatrix* theCSMatForProdToProjBackwardScattering = new G4AdjointCSMatrix(false);
  G4AdjointCSMatrix* theCSMatForScatProjToProjBackwardScattering = new G4AdjointCSMatrix(true);
 
 
  //make the vector of primary energy of the adjoint particle, could try to make this just once ? 
  
   G4double EkinMin =aModel->GetLowEnergyLimit();
   G4double EkinMaxForScat =aModel->GetHighEnergyLimit()*0.999;
   G4double EkinMaxForProd =aModel->GetHighEnergyLimit()*0.999;
   if (aModel->GetSecondPartOfSameType() )EkinMaxForProd =EkinMaxForProd/2.;
   
    
   
   
   
   
   
   //Product to projectile backward scattering
   //-----------------------------------------
   G4double fE=std::pow(10.,1./nbin_pro_decade);
   G4double E2=std::pow(10.,double( int(std::log10(EkinMin)*nbin_pro_decade)+1)/nbin_pro_decade)/fE;
   G4double E1=EkinMin;
   // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
   while (E1 <EkinMaxForProd){
    E1=std::max(EkinMin,E2);
    E1=std::min(EkinMaxForProd,E1);
    std::vector< std::vector< double>* >  aMat= aModel->ComputeAdjointCrossSectionVectorPerVolumeForSecond(aMaterial,E1,nbin_pro_decade);
    if (aMat.size()>=2) {
        std::vector< double>* log_ESecVec=aMat[0];
        std::vector< double>* log_CSVec=aMat[1];
        G4double log_adjointCS=log_CSVec->back();
    
        //normalise CSVec such that it becomes a probability vector
        for (size_t j=0;j<log_CSVec->size();j++) {
                //G4cout<<"CSMan1 "<<(*log_CSVec)[j]<<G4endl;
            if (j==0) (*log_CSVec)[j] = 0.; 
            else (*log_CSVec)[j]=std::log(1.-std::exp((*log_CSVec)[j]-log_adjointCS));
            //G4cout<<"CSMan2 "<<(*log_CSVec)[j]<<G4endl;
        }   
        (*log_CSVec)[log_CSVec->size()-1]=(*log_CSVec)[log_CSVec->size()-2]-std::log(1000.);
        theCSMatForProdToProjBackwardScattering->AddData(std::log(E1),log_adjointCS,log_ESecVec,log_CSVec,0);
    }   
    
    
    
    E1=E2;
    E2*=fE;
   }
   
   //Scattered projectile to projectile backward scattering
   //-----------------------------------------
   
   E2=std::pow(10.,double( int(std::log10(EkinMin)*nbin_pro_decade)+1)/nbin_pro_decade)/fE;
   E1=EkinMin;
   // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
   while (E1 <EkinMaxForScat){
    E1=std::max(EkinMin,E2);
    E1=std::min(EkinMaxForScat,E1);
    std::vector< std::vector< double>* >  aMat= aModel->ComputeAdjointCrossSectionVectorPerVolumeForScatProj(aMaterial,E1,nbin_pro_decade);
    if (aMat.size()>=2) {
        std::vector< double>* log_ESecVec=aMat[0];
        std::vector< double>* log_CSVec=aMat[1];
        G4double log_adjointCS=log_CSVec->back();
    
        for (size_t j=0;j<log_CSVec->size();j++) {
                //G4cout<<"CSMan1 "<<(*log_CSVec)[j]<<G4endl;
            if (j==0) (*log_CSVec)[j] = 0.; 
            else (*log_CSVec)[j]=std::log(1.-std::exp((*log_CSVec)[j]-log_adjointCS));
        //G4cout<<"CSMan2 "<<(*log_CSVec)[j]<<G4endl;if (theAdjPartDef->GetParticleName() == "adj_gamma") return G4Gamma::Gamma();
 
        }   
        (*log_CSVec)[log_CSVec->size()-1]=(*log_CSVec)[log_CSVec->size()-2]-std::log(1000.);
    
        theCSMatForScatProjToProjBackwardScattering->AddData(std::log(E1),log_adjointCS,log_ESecVec,log_CSVec,0);
    }
    E1=E2;
    E2*=fE; 
   }
   
   
   
   
   
   
   
  std::vector<G4AdjointCSMatrix*> res;
  res.clear();
  
  res.push_back(theCSMatForProdToProjBackwardScattering);
  res.push_back(theCSMatForScatProjToProjBackwardScattering); 
  
 /*
  theCSMatForProdToProjBackwardScattering->Write(aModel->GetName()+"_CSMat_"+aMaterial->GetName()+"_ProdToProj.txt");
  theCSMatForScatProjToProjBackwardScattering->Write(aModel->GetName()+"_CSMat_"+aMaterial->GetName()+"_ScatProjToProj.txt");
*/


  return res;
  
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildTotalSigmaTables()

void G4AdjointCSManager::BuildTotalSigmaTables

(

)

Definition at line 269 of file G4AdjointCSManager.cc.

{ if (TotalSigmaTableAreBuilt) return;

  
  const G4ProductionCutsTable* theCoupleTable= G4ProductionCutsTable::GetProductionCutsTable();
 
 
 //Prepare the Sigma table for all AdjointEMModel, will be filled later on 
  for (size_t i=0; i<listOfAdjointEMModel.size();i++){
    listSigmaTableForAdjointModelScatProjToProj[i]->clearAndDestroy();
    listSigmaTableForAdjointModelProdToProj[i]->clearAndDestroy();
    for (size_t j=0;j<theCoupleTable->GetTableSize();j++){
        listSigmaTableForAdjointModelScatProjToProj[i]->push_back(new G4PhysicsLogVector(Tmin, Tmax, nbins));
        listSigmaTableForAdjointModelProdToProj[i]->push_back(new G4PhysicsLogVector(Tmin, Tmax, nbins));
    }
  }
  


  for (size_t i=0;i<theListOfAdjointParticlesInAction.size();i++){
    G4ParticleDefinition* thePartDef = theListOfAdjointParticlesInAction[i];
    DefineCurrentParticle(thePartDef);
    theTotalForwardSigmaTableVector[i]->clearAndDestroy();
    theTotalAdjointSigmaTableVector[i]->clearAndDestroy();
    EminForFwdSigmaTables[i].clear();
    EminForAdjSigmaTables[i].clear();
    EkinofFwdSigmaMax[i].clear();
    EkinofAdjSigmaMax[i].clear();
    //G4cout<<thePartDef->GetParticleName();
    
    for (size_t j=0;j<theCoupleTable->GetTableSize();j++){
        const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(j);
        
        /*
        G4String file_name1=couple->GetMaterial()->GetName()+"_"+thePartDef->GetParticleName()+"_adj_totCS.txt";
        G4String file_name2=couple->GetMaterial()->GetName()+"_"+thePartDef->GetParticleName()+"_fwd_totCS.txt";
        
        std::fstream FileOutputAdjCS(file_name1, std::ios::out);
        std::fstream FileOutputFwdCS(file_name2, std::ios::out);
        
        
        
        FileOutputAdjCS<<std::setiosflags(std::ios::scientific);
        FileOutputAdjCS<<std::setprecision(6);
        FileOutputFwdCS<<std::setiosflags(std::ios::scientific);
        FileOutputFwdCS<<std::setprecision(6);  
        */
              

        //make first the total fwd CS table for FwdProcess
        G4PhysicsVector* aVector =  new G4PhysicsLogVector(Tmin, Tmax, nbins);
        G4bool Emin_found=false;
        G4double sigma_max =0.;
        G4double e_sigma_max =0.;
        for(size_t l=0; l<aVector->GetVectorLength(); l++) { 
            G4double totCS=0.;
            G4double e=aVector->GetLowEdgeEnergy(l);
            for (size_t k=0; k<listOfForwardEmProcess[i]->size(); k++){
                totCS+=(*listOfForwardEmProcess[i])[k]->GetLambda(e, couple);
            }
            for (size_t k=0; k<listOfForwardEnergyLossProcess[i]->size(); k++){
                if (thePartDef == theAdjIon) { // e is considered already as the scaled energy
                        size_t mat_index = couple->GetIndex();
                    G4VEmModel* currentModel = (*listOfForwardEnergyLossProcess[i])[k]->SelectModelForMaterial(e,mat_index);
                    G4double chargeSqRatio =  currentModel->GetChargeSquareRatio(theFwdIon,couple->GetMaterial(),e/massRatio);
                    (*listOfForwardEnergyLossProcess[i])[k]->SetDynamicMassCharge(massRatio,chargeSqRatio);
                }
                G4double e1=e/massRatio;
                totCS+=(*listOfForwardEnergyLossProcess[i])[k]->GetLambda(e1, couple);
            }
            aVector->PutValue(l,totCS);
            if (totCS>sigma_max){
                sigma_max=totCS;
                e_sigma_max = e;
                
            }
            //FileOutputFwdCS<<e<<'\t'<<totCS<<G4endl;
            
            if (totCS>0 && !Emin_found) {
                EminForFwdSigmaTables[i].push_back(e);
                Emin_found=true;
            }
            
        
        }
        //FileOutputFwdCS.close();
        
        EkinofFwdSigmaMax[i].push_back(e_sigma_max);
        
        
        if(!Emin_found) EminForFwdSigmaTables[i].push_back(Tmax);
        
        theTotalForwardSigmaTableVector[i]->push_back(aVector);
        
        
        Emin_found=false;
        sigma_max=0;
        e_sigma_max =0.;
        G4PhysicsVector* aVector1 =  new G4PhysicsLogVector(Tmin, Tmax, nbins);
        for(eindex=0; eindex<aVector->GetVectorLength(); eindex++) { 
            G4double e=aVector->GetLowEdgeEnergy(eindex);
            G4double totCS =ComputeTotalAdjointCS(couple,thePartDef,e*0.9999999/massRatio); //massRatio needed for ions
            aVector1->PutValue(eindex,totCS);
            if (totCS>sigma_max){
                sigma_max=totCS;
                e_sigma_max = e;
                
            }
            //FileOutputAdjCS<<e<<'\t'<<totCS<<G4endl;
            if (totCS>0 && !Emin_found) {
                EminForAdjSigmaTables[i].push_back(e);
                Emin_found=true;
            }
        
        }
        //FileOutputAdjCS.close();
        EkinofAdjSigmaMax[i].push_back(e_sigma_max);
        if(!Emin_found) EminForAdjSigmaTables[i].push_back(Tmax);
            
        theTotalAdjointSigmaTableVector[i]->push_back(aVector1);
        
    }
  }
  TotalSigmaTableAreBuilt =true;
   
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeAdjointCS() [1/2]

G4double G4AdjointCSManager::ComputeAdjointCS	(	G4Material *	aMaterial,
		G4VEmAdjointModel *	aModel,
		G4double	PrimEnergy,
		G4double	Tcut,
		G4bool	IsScatProjToProjCase,
		std::vector< G4double > &	AdjointCS_for_each_element
	)

Definition at line 534 of file G4AdjointCSManager.cc.

{ 
  
  G4double EminSec=0;
  G4double EmaxSec=0;
  
  if (IsScatProjToProjCase){
    EminSec= aModel->GetSecondAdjEnergyMinForScatProjToProjCase(PrimEnergy,Tcut);
    EmaxSec= aModel->GetSecondAdjEnergyMaxForScatProjToProjCase(PrimEnergy);
  }
  else if (PrimEnergy > Tcut || !aModel->GetApplyCutInRange()) {
    EminSec= aModel->GetSecondAdjEnergyMinForProdToProjCase(PrimEnergy);
    EmaxSec= aModel->GetSecondAdjEnergyMaxForProdToProjCase(PrimEnergy);
  }
  if (EminSec >= EmaxSec) return 0.;


  G4bool need_to_compute=false;
  if ( aMaterial!= lastMaterial || PrimEnergy != lastPrimaryEnergy || Tcut != lastTcut){
    lastMaterial =aMaterial;
    lastPrimaryEnergy = PrimEnergy;
    lastTcut=Tcut;
    listOfIndexOfAdjointEMModelInAction.clear();
    listOfIsScatProjToProjCase.clear();
    lastAdjointCSVsModelsAndElements.clear();
    need_to_compute=true;
    
  }
  size_t ind=0;
  if (!need_to_compute){
    need_to_compute=true;
    for (size_t i=0;i<listOfIndexOfAdjointEMModelInAction.size();i++){
        size_t ind1=listOfIndexOfAdjointEMModelInAction[i];
        if (aModel == listOfAdjointEMModel[ind1] && IsScatProjToProjCase == listOfIsScatProjToProjCase[i]){
            need_to_compute=false;
            CS_Vs_Element = lastAdjointCSVsModelsAndElements[ind];
        }
        ind++;
    }
  }
  
  if (need_to_compute){
    size_t ind_model=0;
    for (size_t i=0;i<listOfAdjointEMModel.size();i++){
        if (aModel == listOfAdjointEMModel[i]){
            ind_model=i;
            break;
        }
    }
    G4double Tlow=Tcut;
    if (!listOfAdjointEMModel[ind_model]->GetApplyCutInRange()) Tlow =listOfAdjointEMModel[ind_model]->GetLowEnergyLimit();
    listOfIndexOfAdjointEMModelInAction.push_back(ind_model);   
    listOfIsScatProjToProjCase.push_back(IsScatProjToProjCase);
    CS_Vs_Element.clear();
    if (!aModel->GetUseMatrix()){
        CS_Vs_Element.push_back(aModel->AdjointCrossSection(currentCouple,PrimEnergy,IsScatProjToProjCase));
                         
    
    }
    else if (aModel->GetUseMatrixPerElement()){
            size_t n_el = aMaterial->GetNumberOfElements();
        if (aModel->GetUseOnlyOneMatrixForAllElements()){
            G4AdjointCSMatrix* theCSMatrix;
            if (IsScatProjToProjCase){
                theCSMatrix=theAdjointCSMatricesForScatProjToProj[ind_model][0];
            }
            else    theCSMatrix=theAdjointCSMatricesForProdToProj[ind_model][0];
            G4double CS =0.;
            if (PrimEnergy > Tlow)
                    CS = ComputeAdjointCS(PrimEnergy,theCSMatrix,Tlow);
            G4double factor=0.;
            for (size_t i=0;i<n_el;i++){ //this could be computed only once
                //size_t ind_el = aMaterial->GetElement(i)->GetIndex();
                factor+=aMaterial->GetElement(i)->GetZ()*aMaterial->GetVecNbOfAtomsPerVolume()[i];
            }
            CS *=factor;
            CS_Vs_Element.push_back(CS);
                                
        }
        else {
            for (size_t i=0;i<n_el;i++){
                size_t ind_el = aMaterial->GetElement(i)->GetIndex();
                //G4cout<<aMaterial->GetName()<<G4endl;
                G4AdjointCSMatrix* theCSMatrix;
                if (IsScatProjToProjCase){
                    theCSMatrix=theAdjointCSMatricesForScatProjToProj[ind_model][ind_el];
                }
                else    theCSMatrix=theAdjointCSMatricesForProdToProj[ind_model][ind_el];
                G4double CS =0.;
                if (PrimEnergy > Tlow)
                    CS = ComputeAdjointCS(PrimEnergy,theCSMatrix,Tlow);
                //G4cout<<CS<<G4endl;           
                CS_Vs_Element.push_back(CS*(aMaterial->GetVecNbOfAtomsPerVolume()[i])); 
            }
        }       
        
    }
    else {
        size_t ind_mat = aMaterial->GetIndex();
        G4AdjointCSMatrix* theCSMatrix;
        if (IsScatProjToProjCase){
            theCSMatrix=theAdjointCSMatricesForScatProjToProj[ind_model][ind_mat];
        }
        else    theCSMatrix=theAdjointCSMatricesForProdToProj[ind_model][ind_mat];
        G4double CS =0.;
        if (PrimEnergy > Tlow)
            CS = ComputeAdjointCS(PrimEnergy,theCSMatrix,Tlow);
        CS_Vs_Element.push_back(CS);                            
            
        
    }
    lastAdjointCSVsModelsAndElements.push_back(CS_Vs_Element);
    
  }
  
  
  G4double CS=0;
  for (size_t i=0;i<CS_Vs_Element.size();i++){
    CS+=CS_Vs_Element[i]; //We could put the progressive sum of the CS instead of the CS of an element itself
    
  }
  return CS;
}                           

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeAdjointCS() [2/2]

G4double G4AdjointCSManager::ComputeAdjointCS ( G4double  aPrimEnergy, G4AdjointCSMatrix *  anAdjointCSMatrix, G4double  Tcut  )

private

Definition at line 1003 of file G4AdjointCSManager.cc.

{ 
  std::vector< double> *theLogPrimEnergyVector = anAdjointCSMatrix->GetLogPrimEnergyVector();
  if (theLogPrimEnergyVector->size() ==0){
    G4cout<<"No data are contained in the given AdjointCSMatrix!"<<G4endl;
    G4cout<<"The s"<<G4endl;
    return 0.;
    
  }
  G4double log_Tcut = std::log(Tcut);
  G4double log_E =std::log(aPrimEnergy);
  
  if (aPrimEnergy <= Tcut || log_E > theLogPrimEnergyVector->back()) return 0.;
  
  

  G4AdjointInterpolator* theInterpolator=G4AdjointInterpolator::GetInstance();
 
  size_t ind =theInterpolator->FindPositionForLogVector(log_E,*theLogPrimEnergyVector);
  G4double aLogPrimEnergy1,aLogPrimEnergy2;
  G4double aLogCS1,aLogCS2;
  G4double log01,log02;
  std::vector< double>* aLogSecondEnergyVector1 =0;
  std::vector< double>* aLogSecondEnergyVector2  =0;
  std::vector< double>* aLogProbVector1=0;
  std::vector< double>* aLogProbVector2=0;
  std::vector< size_t>* aLogProbVectorIndex1=0;
  std::vector< size_t>* aLogProbVectorIndex2=0;
  
                                     
  anAdjointCSMatrix->GetData(ind, aLogPrimEnergy1,aLogCS1,log01, aLogSecondEnergyVector1,aLogProbVector1,aLogProbVectorIndex1);
  anAdjointCSMatrix->GetData(ind+1, aLogPrimEnergy2,aLogCS2,log02, aLogSecondEnergyVector2,aLogProbVector2,aLogProbVectorIndex2);
  if (anAdjointCSMatrix->IsScatProjToProjCase()){ //case where the Tcut plays a role
    G4double log_minimum_prob1, log_minimum_prob2;
    log_minimum_prob1=theInterpolator->InterpolateForLogVector(log_Tcut,*aLogSecondEnergyVector1,*aLogProbVector1);
    log_minimum_prob2=theInterpolator->InterpolateForLogVector(log_Tcut,*aLogSecondEnergyVector2,*aLogProbVector2);
    aLogCS1+= log_minimum_prob1;
    aLogCS2+= log_minimum_prob2;
  }
 
  G4double log_adjointCS = theInterpolator->LinearInterpolation(log_E,aLogPrimEnergy1,aLogPrimEnergy2,aLogCS1,aLogCS2);
  return std::exp(log_adjointCS); 
  
  
}    

Here is the call graph for this function:

ComputeTotalAdjointCS()

G4double G4AdjointCSManager::ComputeTotalAdjointCS	(	const G4MaterialCutsCouple *	aMatCutCouple,
		G4ParticleDefinition *	aPart,
		G4double	PrimEnergy
	)

Definition at line 689 of file G4AdjointCSManager.cc.

{
 G4double TotalCS=0.;

 DefineCurrentMaterial(aCouple);

  
 std::vector<G4double> CS_Vs_Element;
 G4double CS;
 for (size_t i=0; i<listOfAdjointEMModel.size();i++){
    
    G4double Tlow=0;
    if (!listOfAdjointEMModel[i]->GetApplyCutInRange()) Tlow =listOfAdjointEMModel[i]->GetLowEnergyLimit();
    else {
        G4ParticleDefinition* theDirSecondPartDef = 
            GetForwardParticleEquivalent(listOfAdjointEMModel[i]->GetAdjointEquivalentOfDirectSecondaryParticleDefinition());
        size_t idx=56;
        if (theDirSecondPartDef->GetParticleName() == "gamma") idx = 0;
        else if (theDirSecondPartDef->GetParticleName() == "e-") idx = 1;
        else if (theDirSecondPartDef->GetParticleName() == "e+") idx = 2;
        if (idx <56) {
            const std::vector<G4double>* aVec = G4ProductionCutsTable::GetProductionCutsTable()->GetEnergyCutsVector(idx);
            Tlow =(*aVec)[aCouple->GetIndex()];
        }   
        
    
    }
    if ( Ekin<=listOfAdjointEMModel[i]->GetHighEnergyLimit() && Ekin>=listOfAdjointEMModel[i]->GetLowEnergyLimit()){
        if (aPartDef == listOfAdjointEMModel[i]->GetAdjointEquivalentOfDirectPrimaryParticleDefinition()){
            CS=ComputeAdjointCS(currentMaterial,
                                   listOfAdjointEMModel[i], 
                                   Ekin, Tlow,true,CS_Vs_Element);
            TotalCS += CS;
            (*listSigmaTableForAdjointModelScatProjToProj[i])[currentMatIndex]->PutValue(eindex,CS);                   
        }
        if (aPartDef == listOfAdjointEMModel[i]->GetAdjointEquivalentOfDirectSecondaryParticleDefinition()){
            CS = ComputeAdjointCS(currentMaterial,
                                   listOfAdjointEMModel[i], 
                                   Ekin, Tlow,false, CS_Vs_Element);
            TotalCS += CS;
            (*listSigmaTableForAdjointModelProdToProj[i])[currentMatIndex]->PutValue(eindex,CS);
        }
        
    }
    else {
        (*listSigmaTableForAdjointModelScatProjToProj[i])[currentMatIndex]->PutValue(eindex,0.);
        (*listSigmaTableForAdjointModelProdToProj[i])[currentMatIndex]->PutValue(eindex,0.);
        
    }
 }
 return TotalCS;
    
 
}   

Here is the call graph for this function:

Here is the caller graph for this function:

DefineCurrentMaterial()

void G4AdjointCSManager::DefineCurrentMaterial ( const G4MaterialCutsCouple *  couple )

private

Definition at line 970 of file G4AdjointCSManager.cc.

{
  if(couple != currentCouple) {
    currentCouple   = const_cast<G4MaterialCutsCouple*> (couple);
    currentMaterial = const_cast<G4Material*> (couple->GetMaterial());
    currentMatIndex = couple->GetIndex();
    lastPartDefForCS =0;
    LastEkinForCS =0;
    LastCSCorrectionFactor =1.;
  }  
}

Here is the call graph for this function:

Here is the caller graph for this function:

DefineCurrentParticle()

void G4AdjointCSManager::DefineCurrentParticle ( const G4ParticleDefinition *  aPartDef )

private

Definition at line 984 of file G4AdjointCSManager.cc.

{
  if(aPartDef != currentParticleDef) {
  
    currentParticleDef= const_cast< G4ParticleDefinition* > (aPartDef);
    massRatio=1;
    if (aPartDef == theAdjIon) massRatio = proton_mass_c2/aPartDef->GetPDGMass();
    currentParticleIndex=1000000;
    for (size_t i=0;i<theListOfAdjointParticlesInAction.size();i++){
        if (aPartDef == theListOfAdjointParticlesInAction[i]) currentParticleIndex=i;
    }   
     
  }  
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetAdjointCSManager()

G4AdjointCSManager * G4AdjointCSManager::GetAdjointCSManager ( )

static

Definition at line 61 of file G4AdjointCSManager.cc.

{ 
  if(theInstance == nullptr) {
    static G4ThreadLocalSingleton<G4AdjointCSManager> inst;
    theInstance = inst.Instance();
  }
  return theInstance; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetAdjointParticleEquivalent()

G4ParticleDefinition * G4AdjointCSManager::GetAdjointParticleEquivalent

(

G4ParticleDefinition *

theFwdPartDef

)

Definition at line 949 of file G4AdjointCSManager.cc.

{
 if (theFwdPartDef->GetParticleName() == "e-") return G4AdjointElectron::AdjointElectron();
 else if (theFwdPartDef->GetParticleName() == "gamma") return G4AdjointGamma::AdjointGamma();
 else if (theFwdPartDef->GetParticleName() == "proton") return G4AdjointProton::AdjointProton();
 else if (theFwdPartDef ==theFwdIon) return theAdjIon;
 
 return 0;  
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetAdjointSigma()

G4double G4AdjointCSManager::GetAdjointSigma	(	G4double	Ekin_nuc,
		size_t	index_model,
		G4bool	is_scat_proj_to_proj,
		const G4MaterialCutsCouple *	aCouple
	)

Definition at line 420 of file G4AdjointCSManager.cc.

{ DefineCurrentMaterial(aCouple);
  G4bool b;
  if (is_scat_proj_to_proj) return (((*listSigmaTableForAdjointModelScatProjToProj[index_model])[currentMatIndex])->GetValue(Ekin_nuc, b));
  else return (((*listSigmaTableForAdjointModelProdToProj[index_model])[currentMatIndex])->GetValue(Ekin_nuc, b));
}                                        

Here is the call graph for this function:

GetContinuousWeightCorrection()

G4double G4AdjointCSManager::GetContinuousWeightCorrection	(	G4ParticleDefinition *	aPartDef,
		G4double	PreStepEkin,
		G4double	AfterStepEkin,
		const G4MaterialCutsCouple *	aCouple,
		G4double	step_length
	)

Definition at line 504 of file G4AdjointCSManager.cc.

{  G4double corr_fac = 1.;
  //return corr_fac;
  //G4double after_adjCS = GetTotalAdjointCS(aPartDef, AfterStepEkin,aCouple);
  G4double after_fwdCS = GetTotalForwardCS(aPartDef, AfterStepEkin,aCouple);
  G4double pre_adjCS = GetTotalAdjointCS(aPartDef, PreStepEkin,aCouple);
  if (!forward_CS_is_used || pre_adjCS ==0. ||  after_fwdCS==0.) {
    forward_CS_is_used=false;
    G4double pre_fwdCS = GetTotalForwardCS(aPartDef, PreStepEkin,aCouple);
    corr_fac *=std::exp((pre_adjCS-pre_fwdCS)*step_length);
    LastCSCorrectionFactor = 1.;
  }
  else {
    LastCSCorrectionFactor = after_fwdCS/pre_adjCS;
  } 
    

 
  return corr_fac; 
}                    

Here is the call graph for this function:

Here is the caller graph for this function:

GetCrossSectionCorrection()

G4double G4AdjointCSManager::GetCrossSectionCorrection	(	G4ParticleDefinition *	aPartDef,
		G4double	PreStepEkin,
		const G4MaterialCutsCouple *	aCouple,
		G4bool &	fwd_is_used,
		G4double &	fwd_TotCS
	)

Definition at line 467 of file G4AdjointCSManager.cc.

{ G4double corr_fac = 1.;
  if (forward_CS_mode && aPartDef ) {
    fwd_TotCS=PrefwdCS;
    if (LastEkinForCS != PreStepEkin || aPartDef != lastPartDefForCS || aCouple!=currentCouple) {
        DefineCurrentMaterial(aCouple);
        PreadjCS = GetTotalAdjointCS(aPartDef, PreStepEkin,aCouple);
        PrefwdCS = GetTotalForwardCS(aPartDef, PreStepEkin,aCouple);
        LastEkinForCS = PreStepEkin;
        lastPartDefForCS = aPartDef;
        if (PrefwdCS >0. &&  PreadjCS >0.) {
            forward_CS_is_used = true;
            LastCSCorrectionFactor = PrefwdCS/PreadjCS;
        }
        else {
            forward_CS_is_used = false;
            LastCSCorrectionFactor = 1.;
            
        }
        
    }
    corr_fac =LastCSCorrectionFactor;
    
    
    
  }  
  else {
    forward_CS_is_used = false;
    LastCSCorrectionFactor = 1.;
  }
  fwd_TotCS=PrefwdCS;   
  fwd_is_used = forward_CS_is_used;
  return  corr_fac;
}                    

Here is the call graph for this function:

Here is the caller graph for this function:

GetEminForTotalCS()

void G4AdjointCSManager::GetEminForTotalCS	(	G4ParticleDefinition *	aPartDef,
		const G4MaterialCutsCouple *	aCouple,
		G4double &	emin_adj,
		G4double &	emin_fwd
	)

Definition at line 429 of file G4AdjointCSManager.cc.

{ DefineCurrentMaterial(aCouple);
  DefineCurrentParticle(aPartDef);
  emin_adj = EminForAdjSigmaTables[currentParticleIndex][currentMatIndex]/massRatio;
  emin_fwd = EminForFwdSigmaTables[currentParticleIndex][currentMatIndex]/massRatio;
  
  
  
}

Here is the call graph for this function:

GetForwardParticleEquivalent()

G4ParticleDefinition * G4AdjointCSManager::GetForwardParticleEquivalent

(

G4ParticleDefinition *

theAdjPartDef

)

Definition at line 960 of file G4AdjointCSManager.cc.

{
 if (theAdjPartDef->GetParticleName() == "adj_e-") return G4Electron::Electron();
 else if (theAdjPartDef->GetParticleName() == "adj_gamma") return G4Gamma::Gamma();
 else if (theAdjPartDef->GetParticleName() == "adj_proton") return G4Proton::Proton();
 else if (theAdjPartDef == theAdjIon) return theFwdIon;
 return 0;  
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMaxAdjTotalCS()

void G4AdjointCSManager::GetMaxAdjTotalCS	(	G4ParticleDefinition *	aPartDef,
		const G4MaterialCutsCouple *	aCouple,
		G4double &	e_sigma_max,
		G4double &	sigma_max
	)

Definition at line 454 of file G4AdjointCSManager.cc.

{ DefineCurrentMaterial(aCouple);
  DefineCurrentParticle(aPartDef);
  e_sigma_max = EkinofAdjSigmaMax[currentParticleIndex][currentMatIndex];
  G4bool b;
  sigma_max =((*theTotalAdjointSigmaTableVector[currentParticleIndex])[currentMatIndex])->GetValue(e_sigma_max, b);
  e_sigma_max/=massRatio;
  
  
}                    

Here is the call graph for this function:

GetMaxFwdTotalCS()

void G4AdjointCSManager::GetMaxFwdTotalCS	(	G4ParticleDefinition *	aPartDef,
		const G4MaterialCutsCouple *	aCouple,
		G4double &	e_sigma_max,
		G4double &	sigma_max
	)

Definition at line 441 of file G4AdjointCSManager.cc.

{ DefineCurrentMaterial(aCouple);
  DefineCurrentParticle(aPartDef);
  e_sigma_max = EkinofFwdSigmaMax[currentParticleIndex][currentMatIndex];
  G4bool b;
  sigma_max =((*theTotalForwardSigmaTableVector[currentParticleIndex])[currentMatIndex])->GetValue(e_sigma_max, b);
  e_sigma_max/=massRatio;
  
  
}

Here is the call graph for this function:

GetNbProcesses()

G4int G4AdjointCSManager::GetNbProcesses

(

)

GetPostStepWeightCorrection()

G4double G4AdjointCSManager::GetPostStepWeightCorrection

(

)

Definition at line 527 of file G4AdjointCSManager.cc.

{//return 1.; 
 return  1./LastCSCorrectionFactor;
    
}                             

Here is the caller graph for this function:

GetTotalAdjointCS()

G4double G4AdjointCSManager::GetTotalAdjointCS	(	G4ParticleDefinition *	aPartDef,
		G4double	Ekin,
		const G4MaterialCutsCouple *	aCouple
	)

Definition at line 397 of file G4AdjointCSManager.cc.

{ DefineCurrentMaterial(aCouple);
  DefineCurrentParticle(aPartDef);  
  G4bool b;
  return (((*theTotalAdjointSigmaTableVector[currentParticleIndex])[currentMatIndex])->GetValue(Ekin*massRatio, b));
  
  
  
}                    

Here is the call graph for this function:

Here is the caller graph for this function:

GetTotalForwardCS()

G4double G4AdjointCSManager::GetTotalForwardCS	(	G4ParticleDefinition *	aPartDef,
		G4double	Ekin,
		const G4MaterialCutsCouple *	aCouple
	)

Definition at line 409 of file G4AdjointCSManager.cc.

{ DefineCurrentMaterial(aCouple);
  DefineCurrentParticle(aPartDef);
  G4bool b;
  return (((*theTotalForwardSigmaTableVector[currentParticleIndex])[currentMatIndex])->GetValue(Ekin*massRatio, b));
  
  
}

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterAdjointParticle()

void G4AdjointCSManager::RegisterAdjointParticle

(

G4ParticleDefinition *

aPartDef

)

Definition at line 161 of file G4AdjointCSManager.cc.

{  G4int index=-1;
   for (size_t i=0;i<theListOfAdjointParticlesInAction.size();i++){
    if (aPartDef->GetParticleName() == theListOfAdjointParticlesInAction[i]->GetParticleName()) index=i;
   }
  
   if (index ==-1){
    listOfForwardEnergyLossProcess.push_back(new std::vector<G4VEnergyLossProcess*>());
    theTotalForwardSigmaTableVector.push_back(new G4PhysicsTable);
    theTotalAdjointSigmaTableVector.push_back(new G4PhysicsTable);
    listOfForwardEmProcess.push_back(new std::vector<G4VEmProcess*>());
    theListOfAdjointParticlesInAction.push_back(aPartDef);
    EminForFwdSigmaTables.push_back(std::vector<G4double> ());
    EminForAdjSigmaTables.push_back(std::vector<G4double> ());
    EkinofFwdSigmaMax.push_back(std::vector<G4double> ());
    EkinofAdjSigmaMax.push_back(std::vector<G4double> ());
    
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterEmAdjointModel()

size_t G4AdjointCSManager::RegisterEmAdjointModel

(

G4VEmAdjointModel *

aModel

)

Definition at line 123 of file G4AdjointCSManager.cc.

{listOfAdjointEMModel.push_back(aModel);
 listSigmaTableForAdjointModelScatProjToProj.push_back(new G4PhysicsTable);
 listSigmaTableForAdjointModelProdToProj.push_back(new G4PhysicsTable);
 return listOfAdjointEMModel.size() -1;
 
}

Here is the caller graph for this function:

RegisterEmProcess()

void G4AdjointCSManager::RegisterEmProcess	(	G4VEmProcess *	aProcess,
		G4ParticleDefinition *	aPartDef
	)

Definition at line 132 of file G4AdjointCSManager.cc.

{ 
  G4ParticleDefinition* anAdjPartDef = GetAdjointParticleEquivalent(aFwdPartDef);
  if (anAdjPartDef && aProcess){
    RegisterAdjointParticle(anAdjPartDef);
    G4int index=-1;
    
    for (size_t i=0;i<theListOfAdjointParticlesInAction.size();i++){
        if (anAdjPartDef->GetParticleName() == theListOfAdjointParticlesInAction[i]->GetParticleName()) index=i;
    }
    listOfForwardEmProcess[index]->push_back(aProcess);
  }
}

Here is the call graph for this function:

RegisterEnergyLossProcess()

void G4AdjointCSManager::RegisterEnergyLossProcess	(	G4VEnergyLossProcess *	aProcess,
		G4ParticleDefinition *	aPartDef
	)

Definition at line 147 of file G4AdjointCSManager.cc.

{
  G4ParticleDefinition* anAdjPartDef = GetAdjointParticleEquivalent(aFwdPartDef);
  if (anAdjPartDef && aProcess){
        RegisterAdjointParticle(anAdjPartDef);
    G4int index=-1;
    for (size_t i=0;i<theListOfAdjointParticlesInAction.size();i++){
        if (anAdjPartDef->GetParticleName() == theListOfAdjointParticlesInAction[i]->GetParticleName()) index=i;
    }
    listOfForwardEnergyLossProcess[index]->push_back(aProcess);
   }
}

Here is the call graph for this function:

SampleElementFromCSMatrices()

G4Element * G4AdjointCSManager::SampleElementFromCSMatrices	(	G4Material *	aMaterial,
		G4VEmAdjointModel *	aModel,
		G4double	PrimEnergy,
		G4double	Tcut,
		G4bool	IsScatProjToProjCase
	)

Definition at line 664 of file G4AdjointCSManager.cc.

{ std::vector<G4double> CS_Vs_Element;
  G4double CS = ComputeAdjointCS(aMaterial,aModel,PrimEnergy,Tcut,IsScatProjToProjCase,CS_Vs_Element);
  G4double rand_var= G4UniformRand();
  G4double SumCS=0.;
  size_t ind=0;
  for (size_t i=0;i<CS_Vs_Element.size();i++){
    SumCS+=CS_Vs_Element[i];
    if (rand_var<=SumCS/CS){
        ind=i;
        break;
    }
  }
 
  return const_cast<G4Element*>(aMaterial->GetElement(ind));
 
 
                        
}                               

Here is the call graph for this function:

Here is the caller graph for this function:

SetFwdCrossSectionMode()

void G4AdjointCSManager::SetFwdCrossSectionMode ( G4bool  aBool )

inline

Definition at line 124 of file G4AdjointCSManager.hh.

{forward_CS_mode=aBool;}

Here is the call graph for this function:

SetIon()

void G4AdjointCSManager::SetIon ( G4ParticleDefinition *  adjIon, G4ParticleDefinition *  fwdIon  )

inline

Definition at line 171 of file G4AdjointCSManager.hh.

                                                 {theAdjIon=adjIon; theFwdIon =fwdIon;}

SetNbins()

void G4AdjointCSManager::SetNbins ( G4int  aInt )

inline

Definition at line 170 of file G4AdjointCSManager.hh.

{nbins=aInt;}

SetTmax()

void G4AdjointCSManager::SetTmax ( G4double  aVal )

inline

Definition at line 169 of file G4AdjointCSManager.hh.

{Tmax=aVal;}

SetTmin()

void G4AdjointCSManager::SetTmin ( G4double  aVal )

inline

Definition at line 168 of file G4AdjointCSManager.hh.

{Tmin=aVal;}

Friends And Related Function Documentation

G4ThreadLocalSingleton< G4AdjointCSManager >

friend class G4ThreadLocalSingleton< G4AdjointCSManager >

friend

Definition at line 72 of file G4AdjointCSManager.hh.

Member Data Documentation

CrossSectionMatrixesAreBuilt

G4bool G4AdjointCSManager::CrossSectionMatrixesAreBuilt

private

Definition at line 199 of file G4AdjointCSManager.hh.

currentCouple

G4MaterialCutsCouple* G4AdjointCSManager::currentCouple

private

Definition at line 231 of file G4AdjointCSManager.hh.

currentMaterial

G4Material* G4AdjointCSManager::currentMaterial

private

Definition at line 232 of file G4AdjointCSManager.hh.

currentMatIndex

size_t G4AdjointCSManager::currentMatIndex

private

Definition at line 233 of file G4AdjointCSManager.hh.

currentParticleDef

G4ParticleDefinition* G4AdjointCSManager::currentParticleDef

private

Definition at line 201 of file G4AdjointCSManager.hh.

currentParticleIndex

size_t G4AdjointCSManager::currentParticleIndex

private

Definition at line 200 of file G4AdjointCSManager.hh.

eindex

size_t G4AdjointCSManager::eindex

private

Definition at line 265 of file G4AdjointCSManager.hh.

EkinofAdjSigmaMax

std::vector< std::vector<G4double> > G4AdjointCSManager::EkinofAdjSigmaMax

private

Definition at line 210 of file G4AdjointCSManager.hh.

EkinofFwdSigmaMax

std::vector< std::vector<G4double> > G4AdjointCSManager::EkinofFwdSigmaMax

private

Definition at line 209 of file G4AdjointCSManager.hh.

EminForAdjSigmaTables

std::vector< std::vector<G4double> > G4AdjointCSManager::EminForAdjSigmaTables

private

Definition at line 208 of file G4AdjointCSManager.hh.

EminForFwdSigmaTables

std::vector< std::vector<G4double> > G4AdjointCSManager::EminForFwdSigmaTables

private

Definition at line 207 of file G4AdjointCSManager.hh.

forward_CS_is_used

G4bool G4AdjointCSManager::forward_CS_is_used

private

Definition at line 242 of file G4AdjointCSManager.hh.

forward_CS_mode

G4bool G4AdjointCSManager::forward_CS_mode

private

Definition at line 243 of file G4AdjointCSManager.hh.

lastAdjointCSVsModelsAndElements

std::vector< std::vector<G4double> > G4AdjointCSManager::lastAdjointCSVsModelsAndElements

private

Definition at line 198 of file G4AdjointCSManager.hh.

LastCSCorrectionFactor

G4double G4AdjointCSManager::LastCSCorrectionFactor

private

Definition at line 251 of file G4AdjointCSManager.hh.

LastEkinForCS

G4double G4AdjointCSManager::LastEkinForCS

private

Definition at line 250 of file G4AdjointCSManager.hh.

lastMaterial

G4Material* G4AdjointCSManager::lastMaterial

private

Definition at line 193 of file G4AdjointCSManager.hh.

lastPartDefForCS

G4ParticleDefinition* G4AdjointCSManager::lastPartDefForCS

private

Definition at line 252 of file G4AdjointCSManager.hh.

lastPrimaryEnergy

G4double G4AdjointCSManager::lastPrimaryEnergy

private

Definition at line 194 of file G4AdjointCSManager.hh.

lastTcut

G4double G4AdjointCSManager::lastTcut

private

Definition at line 195 of file G4AdjointCSManager.hh.

listOfAdjointEMModel

std::vector< G4VEmAdjointModel*> G4AdjointCSManager::listOfAdjointEMModel

private

Definition at line 179 of file G4AdjointCSManager.hh.

listOfForwardEmProcess

std::vector< std::vector<G4VEmProcess*>* > G4AdjointCSManager::listOfForwardEmProcess

private

Definition at line 219 of file G4AdjointCSManager.hh.

listOfForwardEnergyLossProcess

std::vector< std::vector<G4VEnergyLossProcess*>* > G4AdjointCSManager::listOfForwardEnergyLossProcess

private

Definition at line 220 of file G4AdjointCSManager.hh.

listOfIndexOfAdjointEMModelInAction

std::vector< size_t> G4AdjointCSManager::listOfIndexOfAdjointEMModelInAction

private

Definition at line 196 of file G4AdjointCSManager.hh.

listOfIsScatProjToProjCase

std::vector< G4bool> G4AdjointCSManager::listOfIsScatProjToProjCase

private

Definition at line 197 of file G4AdjointCSManager.hh.

listSigmaTableForAdjointModelProdToProj

std::vector<G4PhysicsTable*> G4AdjointCSManager::listSigmaTableForAdjointModelProdToProj

private

Definition at line 215 of file G4AdjointCSManager.hh.

listSigmaTableForAdjointModelScatProjToProj

std::vector<G4PhysicsTable*> G4AdjointCSManager::listSigmaTableForAdjointModelScatProjToProj

private

Definition at line 214 of file G4AdjointCSManager.hh.

massRatio

G4double G4AdjointCSManager::massRatio

private

Definition at line 258 of file G4AdjointCSManager.hh.

nbins

G4int G4AdjointCSManager::nbins

private

Definition at line 227 of file G4AdjointCSManager.hh.

PostadjCS

G4double G4AdjointCSManager::PostadjCS

private

Definition at line 248 of file G4AdjointCSManager.hh.

PostfwdCS

G4double G4AdjointCSManager::PostfwdCS

private

Definition at line 249 of file G4AdjointCSManager.hh.

PreadjCS

G4double G4AdjointCSManager::PreadjCS

private

Definition at line 248 of file G4AdjointCSManager.hh.

PrefwdCS

G4double G4AdjointCSManager::PrefwdCS

private

Definition at line 249 of file G4AdjointCSManager.hh.

theAdjIon

G4ParticleDefinition* G4AdjointCSManager::theAdjIon

private

Definition at line 256 of file G4AdjointCSManager.hh.

theAdjointCSMatricesForProdToProj

std::vector< std::vector<G4AdjointCSMatrix*> > G4AdjointCSManager::theAdjointCSMatricesForProdToProj

private

Definition at line 178 of file G4AdjointCSManager.hh.

theAdjointCSMatricesForScatProjToProj

std::vector< std::vector<G4AdjointCSMatrix*> > G4AdjointCSManager::theAdjointCSMatricesForScatProjToProj

private

Definition at line 177 of file G4AdjointCSManager.hh.

theFwdIon

G4ParticleDefinition* G4AdjointCSManager::theFwdIon

private

Definition at line 257 of file G4AdjointCSManager.hh.

theInstance

G4ThreadLocal G4AdjointCSManager * G4AdjointCSManager::theInstance = nullptr

staticprivate

Definition at line 176 of file G4AdjointCSManager.hh.

theListOfAdjointParticlesInAction

std::vector< G4ParticleDefinition*> G4AdjointCSManager::theListOfAdjointParticlesInAction

private

Definition at line 224 of file G4AdjointCSManager.hh.

theTotalAdjointSigmaTableVector

std::vector<G4PhysicsTable*> G4AdjointCSManager::theTotalAdjointSigmaTableVector

private

Definition at line 206 of file G4AdjointCSManager.hh.

theTotalForwardSigmaTableVector

std::vector<G4PhysicsTable*> G4AdjointCSManager::theTotalForwardSigmaTableVector

private

Definition at line 205 of file G4AdjointCSManager.hh.

Tmax

G4double G4AdjointCSManager::Tmax

private

Definition at line 226 of file G4AdjointCSManager.hh.

Tmin

G4double G4AdjointCSManager::Tmin

private

Definition at line 226 of file G4AdjointCSManager.hh.

TotalSigmaTableAreBuilt

G4bool G4AdjointCSManager::TotalSigmaTableAreBuilt

private

Definition at line 211 of file G4AdjointCSManager.hh.

verbose

G4int G4AdjointCSManager::verbose

private

Definition at line 235 of file G4AdjointCSManager.hh.

---

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

• G4AdjointCSManager.hh
• G4AdjointCSManager.cc