G4AdjointCSManager Class Reference

#include <G4AdjointCSManager.hh>

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

Static Public Member Functions
static G4AdjointCSManager *	GetAdjointCSManager ()

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

Private Attributes
G4ParticleDefinition *	fAdjIon = nullptr
std::vector< std::vector< G4AdjointCSMatrix * > >	fAdjointCSMatricesForProdToProj
std::vector< std::vector< G4AdjointCSMatrix * > >	fAdjointCSMatricesForScatProjToProj
std::vector< G4VEmAdjointModel * >	fAdjointModels
std::vector< G4ParticleDefinition * >	fAdjointParticlesInAction
G4bool	fCSMatricesBuilt = false
G4MaterialCutsCouple *	fCurrentCouple = nullptr
G4Material *	fCurrentMaterial = nullptr
size_t	fCurrentMatIndex = 0
size_t	fCurrentParticleIndex = 0
std::vector< std::vector< G4double > >	fEkinofAdjSigmaMax
std::vector< std::vector< G4double > >	fEkinofFwdSigmaMax
std::vector< std::vector< G4double > >	fEminForAdjSigmaTables
std::vector< std::vector< G4double > >	fEminForFwdSigmaTables
G4bool	fForwardCSMode = true
G4bool	fForwardCSUsed = true
std::vector< std::vector< G4VEnergyLossProcess * > * >	fForwardLossProcesses
std::vector< std::vector< G4VEmProcess * > * >	fForwardProcesses
G4ParticleDefinition *	fFwdIon = nullptr
std::vector< size_t >	fIndexOfAdjointEMModelInAction
std::vector< G4bool >	fIsScatProjToProj
std::vector< std::vector< G4double > >	fLastAdjointCSVsModelsAndElements
G4double	fLastCSCorrectionFactor = 1.
G4double	fMassRatio = 1.
G4bool	fSigmaTableBuilt = false
std::vector< G4PhysicsTable * >	fSigmaTableForAdjointModelProdToProj
std::vector< G4PhysicsTable * >	fSigmaTableForAdjointModelScatProjToProj
std::vector< G4PhysicsTable * >	fTotalAdjSigmaTable
std::vector< G4PhysicsTable * >	fTotalFwdSigmaTable

Static Private Attributes
static G4ThreadLocal G4AdjointCSManager *	fInstance = nullptr
static constexpr G4int	fNbins = 320
static constexpr G4double	fTmax = 100. * CLHEP::TeV
static constexpr G4double	fTmin = 0.1 * CLHEP::keV

Friends
class	G4ThreadLocalSingleton< G4AdjointCSManager >

Detailed Description

Definition at line 58 of file G4AdjointCSManager.hh.

Constructor & Destructor Documentation

~G4AdjointCSManager()

G4AdjointCSManager::~G4AdjointCSManager

(

)

Definition at line 76 of file G4AdjointCSManager.cc.

{
  for (auto p : fAdjointCSMatricesForProdToProj) {
    for (auto p1 : p) {
      if (p1) {
        delete p1;
        p1 = nullptr;
      }
    }
    p.clear();
  }
  fAdjointCSMatricesForProdToProj.clear();
 
  for (auto p : fAdjointCSMatricesForScatProjToProj) {
    for (auto p1 : p) {
      if (p1) {
        delete p1;
        p1 = nullptr;
      }
    }
    p.clear();
  }
  fAdjointCSMatricesForScatProjToProj.clear();
 
  for (auto p : fAdjointModels) {
    if (p) {
      delete p;
      p = nullptr;
    }
  }
  fAdjointModels.clear();
 
  for (auto p : fTotalAdjSigmaTable) {
    p->clearAndDestroy();
    delete p;
    p = nullptr;
  }
  fTotalAdjSigmaTable.clear();
 
  for (auto p : fSigmaTableForAdjointModelScatProjToProj) {
    p->clearAndDestroy();
    delete p;
    p = nullptr;
  }
  fSigmaTableForAdjointModelScatProjToProj.clear();
 
  for (auto p : fSigmaTableForAdjointModelProdToProj) {
    p->clearAndDestroy();
    delete p;
    p = nullptr;
  }
  fSigmaTableForAdjointModelProdToProj.clear();
 
  for (auto p : fTotalFwdSigmaTable) {
    p->clearAndDestroy();
    delete p;
    p = nullptr;
  }
  fTotalFwdSigmaTable.clear();
 
  for (auto p : fForwardProcesses) {
    delete p;
    p = nullptr;
  }
  fForwardProcesses.clear();
 
  for (auto p : fForwardLossProcesses) {
    delete p;
    p = nullptr;
  }
  fForwardLossProcesses.clear();
}

References fAdjointCSMatricesForProdToProj, fAdjointCSMatricesForScatProjToProj, fAdjointModels, fForwardLossProcesses, fForwardProcesses, fSigmaTableForAdjointModelProdToProj, fSigmaTableForAdjointModelScatProjToProj, fTotalAdjSigmaTable, and fTotalFwdSigmaTable.

G4AdjointCSManager()

G4AdjointCSManager::G4AdjointCSManager ( )

private

Definition at line 68 of file G4AdjointCSManager.cc.

{
  RegisterAdjointParticle(G4AdjointElectron::AdjointElectron());
  RegisterAdjointParticle(G4AdjointGamma::AdjointGamma());
  RegisterAdjointParticle(G4AdjointProton::AdjointProton());
}

References G4AdjointElectron::AdjointElectron(), G4AdjointGamma::AdjointGamma(), G4AdjointProton::AdjointProton(), and RegisterAdjointParticle().

Member Function Documentation

BuildCrossSectionMatrices()

void G4AdjointCSManager::BuildCrossSectionMatrices

(

)

Definition at line 222 of file G4AdjointCSManager.cc.

{
  if(fCSMatricesBuilt)
    return;
  // The Tcut and Tmax matrices will be computed probably just once.
  // When Tcut changes, 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
  // 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 recomputing 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)
 
  fAdjointCSMatricesForScatProjToProj.clear();
  fAdjointCSMatricesForProdToProj.clear();
  const G4ElementTable* theElementTable   = G4Element::GetElementTable();
  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
 
  G4cout << "========== Computation of cross section matrices for adjoint "
            "models =========="
         << G4endl;
  for(const auto& aModel : fAdjointModels)
  {
    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*>();
      if(aModel->GetUseMatrixPerElement())
      {
        if(aModel->GetUseOnlyOneMatrixForAllElements())
        {
          std::vector<G4AdjointCSMatrix*> two_matrices =
            BuildCrossSectionsModelAndElement(aModel, 1, 1, 80);
          aListOfMat1->push_back(two_matrices[0]);
          aListOfMat2->push_back(two_matrices[1]);
        }
        else
        {
          for(const auto& anElement : *theElementTable)
          {
            G4int Z = G4lrint(anElement->GetZ());
            G4int A = G4lrint(anElement->GetN());
            std::vector<G4AdjointCSMatrix*> two_matrices =
              BuildCrossSectionsModelAndElement(aModel, Z, A, 40);
            aListOfMat1->push_back(two_matrices[0]);
            aListOfMat2->push_back(two_matrices[1]);
          }
        }
      }
      else
      {  // Per material case
        for(const auto& aMaterial : *theMaterialTable)
        {
          std::vector<G4AdjointCSMatrix*> two_matrices =
            BuildCrossSectionsModelAndMaterial(aModel, aMaterial, 40);
          aListOfMat1->push_back(two_matrices[0]);
          aListOfMat2->push_back(two_matrices[1]);
        }
      }
      fAdjointCSMatricesForProdToProj.push_back(*aListOfMat1);
      fAdjointCSMatricesForScatProjToProj.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;
      fAdjointCSMatricesForProdToProj.push_back(two_empty_matrices);
      fAdjointCSMatricesForScatProjToProj.push_back(two_empty_matrices);
    }
  }
  G4cout << "              All adjoint cross section matrices are computed!"
         << G4endl;
  G4cout
    << "======================================================================"
    << G4endl;
 
  fCSMatricesBuilt = true;
}

References A, BuildCrossSectionsModelAndElement(), BuildCrossSectionsModelAndMaterial(), fAdjointCSMatricesForProdToProj, fAdjointCSMatricesForScatProjToProj, fAdjointModels, fCSMatricesBuilt, G4cout, G4endl, G4lrint(), G4Element::GetElementTable(), G4Material::GetMaterialTable(), and Z.

Referenced by G4AdjointForcedInteractionForGamma::BuildPhysicsTable(), and G4VAdjointReverseReaction::BuildPhysicsTable().

BuildCrossSectionsModelAndElement()

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

private

Definition at line 828 of file G4AdjointCSManager.cc.

{
  G4AdjointCSMatrix* theCSMatForProdToProjBackwardScattering =
    new G4AdjointCSMatrix(false);
  G4AdjointCSMatrix* theCSMatForScatProjToProjBackwardScattering =
    new G4AdjointCSMatrix(true);
 
  // make the vector of primary energy of the adjoint particle. 
  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 dE = std::pow(10., 1. / nbin_pro_decade);
  G4double E2 =
    std::pow(10., double(int(std::log10(EkinMin) * nbin_pro_decade) + 1) /
                    nbin_pro_decade) / dE;
  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 *= dE;
  }
 
  // Scattered projectile to projectile backward scattering
  E2 = std::pow(10., G4double(int(std::log10(EkinMin) * nbin_pro_decade) + 1) /
                       nbin_pro_decade) / dE;
  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<G4double>*> aMat =
      aModel->ComputeAdjointCrossSectionVectorPerAtomForScatProj(
        E1, Z, A, nbin_pro_decade);
    if(aMat.size() >= 2)
    {
      std::vector<G4double>* log_ESecVec = aMat[0];
      std::vector<G4double>* 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 *= dE;
  }
 
  std::vector<G4AdjointCSMatrix*> res;
  res.push_back(theCSMatForProdToProjBackwardScattering);
  res.push_back(theCSMatForScatProjToProjBackwardScattering);
 
  return res;
}

References A, G4AdjointCSMatrix::AddData(), G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerAtomForScatProj(), G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerAtomForSecond(), dE, G4VEmAdjointModel::GetHighEnergyLimit(), G4VEmAdjointModel::GetLowEnergyLimit(), G4VEmAdjointModel::GetSecondPartOfSameType(), G4INCL::Math::max(), G4INCL::Math::min(), and Z.

Referenced by BuildCrossSectionMatrices().

BuildCrossSectionsModelAndMaterial()

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

private

Definition at line 925 of file G4AdjointCSManager.cc.

{
  G4AdjointCSMatrix* theCSMatForProdToProjBackwardScattering =
    new G4AdjointCSMatrix(false);
  G4AdjointCSMatrix* theCSMatForScatProjToProjBackwardScattering =
    new G4AdjointCSMatrix(true);
 
  G4double EkinMin        = aModel->GetLowEnergyLimit();
  G4double EkinMaxForScat = aModel->GetHighEnergyLimit() * 0.999;
  G4double EkinMaxForProd = aModel->GetHighEnergyLimit() * 0.999;
  if(aModel->GetSecondPartOfSameType())
    EkinMaxForProd /= 2.;
 
  // Product to projectile backward scattering
  G4double dE = std::pow(10., 1. / nbin_pro_decade);
  G4double E2 =
    std::pow(10., double(int(std::log10(EkinMin) * nbin_pro_decade) + 1) /
                    nbin_pro_decade) / dE;
  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<G4double>*> aMat =
      aModel->ComputeAdjointCrossSectionVectorPerVolumeForSecond(
        aMaterial, E1, nbin_pro_decade);
    if(aMat.size() >= 2)
    {
      std::vector<G4double>* log_ESecVec = aMat[0];
      std::vector<G4double>* 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));
      }
      (*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 *= dE;
  }
 
  // Scattered projectile to projectile backward scattering
  E2 =
    std::pow(10., G4double(G4int(std::log10(EkinMin) * nbin_pro_decade) + 1) /
                    nbin_pro_decade) /
    dE;
  E1 = EkinMin;
  while(E1 < EkinMaxForScat)
  {
    E1 = std::max(EkinMin, E2);
    E1 = std::min(EkinMaxForScat, E1);
    std::vector<std::vector<G4double>*> aMat =
      aModel->ComputeAdjointCrossSectionVectorPerVolumeForScatProj(
        aMaterial, E1, nbin_pro_decade);
    if(aMat.size() >= 2)
    {
      std::vector<G4double>* log_ESecVec = aMat[0];
      std::vector<G4double>* log_CSVec   = aMat[1];
      G4double log_adjointCS             = log_CSVec->back();
 
      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));
      }
      (*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 *= dE;
  }
 
  std::vector<G4AdjointCSMatrix*> res;
  res.push_back(theCSMatForProdToProjBackwardScattering);
  res.push_back(theCSMatForScatProjToProjBackwardScattering);
 
  return res;
}

References G4AdjointCSMatrix::AddData(), G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForSecond(), dE, G4VEmAdjointModel::GetHighEnergyLimit(), G4VEmAdjointModel::GetLowEnergyLimit(), G4VEmAdjointModel::GetSecondPartOfSameType(), G4INCL::Math::max(), and G4INCL::Math::min().

Referenced by BuildCrossSectionMatrices().

BuildTotalSigmaTables()

void G4AdjointCSManager::BuildTotalSigmaTables

(

)

Definition at line 317 of file G4AdjointCSManager.cc.

{
  if(fSigmaTableBuilt)
    return;
 
  const G4ProductionCutsTable* theCoupleTable =
    G4ProductionCutsTable::GetProductionCutsTable();
 
  // Prepare the Sigma table for all AdjointEMModel, will be filled later on
  for(size_t i = 0; i < fAdjointModels.size(); ++i)
  {
    fSigmaTableForAdjointModelScatProjToProj[i]->clearAndDestroy();
    fSigmaTableForAdjointModelProdToProj[i]->clearAndDestroy();
    for(size_t j = 0; j < theCoupleTable->GetTableSize(); ++j)
    {
      fSigmaTableForAdjointModelScatProjToProj[i]->push_back(
        new G4PhysicsLogVector(fTmin, fTmax, fNbins));
      fSigmaTableForAdjointModelProdToProj[i]->push_back(
        new G4PhysicsLogVector(fTmin, fTmax, fNbins));
    }
  }
 
  for(size_t i = 0; i < fAdjointParticlesInAction.size(); ++i)
  {
    G4ParticleDefinition* thePartDef = fAdjointParticlesInAction[i];
    DefineCurrentParticle(thePartDef);
    fTotalFwdSigmaTable[i]->clearAndDestroy();
    fTotalAdjSigmaTable[i]->clearAndDestroy();
    fEminForFwdSigmaTables[i].clear();
    fEminForAdjSigmaTables[i].clear();
    fEkinofFwdSigmaMax[i].clear();
    fEkinofAdjSigmaMax[i].clear();
 
    for(size_t j = 0; j < theCoupleTable->GetTableSize(); ++j)
    {
      const G4MaterialCutsCouple* couple =
        theCoupleTable->GetMaterialCutsCouple(j);
 
      // make first the total fwd CS table for FwdProcess
      G4PhysicsVector* aVector = new G4PhysicsLogVector(fTmin, fTmax, fNbins);
      G4bool Emin_found        = false;
      G4double sigma_max       = 0.;
      G4double e_sigma_max     = 0.;
      for(size_t l = 0; l < fNbins; ++l)
      {
        G4double totCS = 0.;
        G4double e     = aVector->Energy(l);
        for(size_t k = 0; k < fForwardProcesses[i]->size(); ++k)
        {
          totCS += (*fForwardProcesses[i])[k]->GetLambda(e, couple);
        }
        for(size_t k = 0; k < fForwardLossProcesses[i]->size(); ++k)
        {
          if(thePartDef == fAdjIon)
          {  // e is considered already as the scaled energy
            size_t mat_index = couple->GetIndex();
            G4VEmModel* currentModel =
              (*fForwardLossProcesses[i])[k]->SelectModelForMaterial(e,
                                                                     mat_index);
            G4double chargeSqRatio = currentModel->GetChargeSquareRatio(
              fFwdIon, couple->GetMaterial(), e / fMassRatio);
            (*fForwardLossProcesses[i])[k]->SetDynamicMassCharge(fMassRatio,
                                                                 chargeSqRatio);
          }
          G4double e1 = e / fMassRatio;
          totCS += (*fForwardLossProcesses[i])[k]->GetLambda(e1, couple);
        }
        aVector->PutValue(l, totCS);
        if(totCS > sigma_max)
        {
          sigma_max   = totCS;
          e_sigma_max = e;
        }
        if(totCS > 0 && !Emin_found)
        {
          fEminForFwdSigmaTables[i].push_back(e);
          Emin_found = true;
        }
      }
 
      fEkinofFwdSigmaMax[i].push_back(e_sigma_max);
 
      if(!Emin_found)
        fEminForFwdSigmaTables[i].push_back(fTmax);
 
      fTotalFwdSigmaTable[i]->push_back(aVector);
 
      Emin_found                = false;
      sigma_max                 = 0;
      e_sigma_max               = 0.;
      G4PhysicsVector* aVector1 = new G4PhysicsLogVector(fTmin, fTmax, fNbins);
      for(size_t eindex = 0; eindex < fNbins; ++eindex)
      {
        G4double e     = aVector1->Energy(eindex);
        G4double totCS = ComputeTotalAdjointCS(
          couple, thePartDef,
          e * 0.9999999 / fMassRatio);  // fMassRatio needed for ions
        aVector1->PutValue(eindex, totCS);
        if(totCS > sigma_max)
        {
          sigma_max   = totCS;
          e_sigma_max = e;
        }
        if(totCS > 0 && !Emin_found)
        {
          fEminForAdjSigmaTables[i].push_back(e);
          Emin_found = true;
        }
      }
      fEkinofAdjSigmaMax[i].push_back(e_sigma_max);
      if(!Emin_found)
        fEminForAdjSigmaTables[i].push_back(fTmax);
 
      fTotalAdjSigmaTable[i]->push_back(aVector1);
    }
  }
  fSigmaTableBuilt = true;
}

References ComputeTotalAdjointCS(), DefineCurrentParticle(), e1, G4PhysicsVector::Energy(), fAdjIon, fAdjointModels, fAdjointParticlesInAction, fEkinofAdjSigmaMax, fEkinofFwdSigmaMax, fEminForAdjSigmaTables, fEminForFwdSigmaTables, fForwardLossProcesses, fForwardProcesses, fFwdIon, fMassRatio, fNbins, fSigmaTableBuilt, fSigmaTableForAdjointModelProdToProj, fSigmaTableForAdjointModelScatProjToProj, fTmax, fTmin, fTotalAdjSigmaTable, fTotalFwdSigmaTable, G4VEmModel::GetChargeSquareRatio(), G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), and G4PhysicsVector::PutValue().

Referenced by G4AdjointForcedInteractionForGamma::BuildPhysicsTable(), and G4VAdjointReverseReaction::BuildPhysicsTable().

ComputeAdjointCS() [1/2]

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

private

Definition at line 1087 of file G4AdjointCSManager.cc.

{
  std::vector<double>* theLogPrimEnergyVector =
    anAdjointCSMatrix->GetLogPrimEnergyVector();
  if(theLogPrimEnergyVector->empty())
  {
    G4cout << "No data are contained in the given AdjointCSMatrix!" << 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<G4double>* aLogSecondEnergyVector1 = nullptr;
  std::vector<G4double>* aLogSecondEnergyVector2 = nullptr;
  std::vector<G4double>* aLogProbVector1         = nullptr;
  std::vector<G4double>* aLogProbVector2         = nullptr;
  std::vector<size_t>* aLogProbVectorIndex1      = nullptr;
  std::vector<size_t>* aLogProbVectorIndex2      = nullptr;
 
  anAdjointCSMatrix->GetData(ind, aLogPrimEnergy1, aLogCS1, log01,
                             aLogSecondEnergyVector1, aLogProbVector1,
                             aLogProbVectorIndex1);
  anAdjointCSMatrix->GetData(ind + 1, aLogPrimEnergy2, aLogCS2, log02,
                             aLogSecondEnergyVector2, aLogProbVector2,
                             aLogProbVectorIndex2);
  if (! (aLogProbVector1 && aLogProbVector2 &&
               aLogSecondEnergyVector1 && aLogSecondEnergyVector2)){
     return  0.;
  }
 
  if(anAdjointCSMatrix->IsScatProjToProj())
  {  // 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);
}

References G4AdjointInterpolator::FindPositionForLogVector(), G4cout, G4endl, G4AdjointCSMatrix::GetData(), G4AdjointInterpolator::GetInstance(), G4AdjointCSMatrix::GetLogPrimEnergyVector(), G4AdjointInterpolator::InterpolateForLogVector(), G4AdjointCSMatrix::IsScatProjToProj(), and G4AdjointInterpolator::LinearInterpolation().

ComputeAdjointCS() [2/2]

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

Definition at line 584 of file G4AdjointCSManager.cc.

{
  G4double EminSec = 0.;
  G4double EmaxSec = 0.;
 
  static G4double lastPrimaryEnergy = 0.;
  static G4double lastTcut          = 0.;
  static G4Material* lastMaterial   = nullptr;
 
  if(isScatProjToProj)
  {
    EminSec = aModel->GetSecondAdjEnergyMinForScatProjToProj(PrimEnergy, Tcut);
    EmaxSec = aModel->GetSecondAdjEnergyMaxForScatProjToProj(PrimEnergy);
  }
  else if(PrimEnergy > Tcut || !aModel->GetApplyCutInRange())
  {
    EminSec = aModel->GetSecondAdjEnergyMinForProdToProj(PrimEnergy);
    EmaxSec = aModel->GetSecondAdjEnergyMaxForProdToProj(PrimEnergy);
  }
  if(EminSec >= EmaxSec)
    return 0.;
 
  G4bool need_to_compute = false;
  if(aMaterial != lastMaterial || PrimEnergy != lastPrimaryEnergy ||
     Tcut != lastTcut)
  {
    lastMaterial      = aMaterial;
    lastPrimaryEnergy = PrimEnergy;
    lastTcut          = Tcut;
    fIndexOfAdjointEMModelInAction.clear();
    fIsScatProjToProj.clear();
    fLastAdjointCSVsModelsAndElements.clear();
    need_to_compute = true;
  }
 
  size_t ind = 0;
  if(!need_to_compute)
  {
    need_to_compute = true;
    for(size_t i = 0; i < fIndexOfAdjointEMModelInAction.size(); ++i)
    {
      size_t ind1 = fIndexOfAdjointEMModelInAction[i];
      if(aModel == fAdjointModels[ind1] &&
         isScatProjToProj == fIsScatProjToProj[i])
      {
        need_to_compute = false;
        CS_Vs_Element   = fLastAdjointCSVsModelsAndElements[ind];
      }
      ++ind;
    }
  }
 
  if(need_to_compute)
  {
    size_t ind_model = 0;
    for(size_t i = 0; i < fAdjointModels.size(); ++i)
    {
      if(aModel == fAdjointModels[i])
      {
        ind_model = i;
        break;
      }
    }
    G4double Tlow = Tcut;
    if(!fAdjointModels[ind_model]->GetApplyCutInRange())
      Tlow = fAdjointModels[ind_model]->GetLowEnergyLimit();
    fIndexOfAdjointEMModelInAction.push_back(ind_model);
    fIsScatProjToProj.push_back(isScatProjToProj);
    CS_Vs_Element.clear();
    if(!aModel->GetUseMatrix())
    {
      CS_Vs_Element.push_back(aModel->AdjointCrossSection(
        fCurrentCouple, PrimEnergy, isScatProjToProj));
    }
    else if(aModel->GetUseMatrixPerElement())
    {
      size_t n_el = aMaterial->GetNumberOfElements();
      if(aModel->GetUseOnlyOneMatrixForAllElements())
      {
        G4AdjointCSMatrix* theCSMatrix;
        if(isScatProjToProj)
        {
          theCSMatrix = fAdjointCSMatricesForScatProjToProj[ind_model][0];
        }
        else
          theCSMatrix = fAdjointCSMatricesForProdToProj[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
          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();
          G4AdjointCSMatrix* theCSMatrix;
          if(isScatProjToProj)
          {
            theCSMatrix =
              fAdjointCSMatricesForScatProjToProj[ind_model][ind_el];
          }
          else
            theCSMatrix = fAdjointCSMatricesForProdToProj[ind_model][ind_el];
          G4double CS = 0.;
          if(PrimEnergy > Tlow)
            CS = ComputeAdjointCS(PrimEnergy, theCSMatrix, Tlow);
          CS_Vs_Element.push_back(CS *
                                  (aMaterial->GetVecNbOfAtomsPerVolume()[i]));
        }
      }
    }
    else
    {
      size_t ind_mat = aMaterial->GetIndex();
      G4AdjointCSMatrix* theCSMatrix;
      if(isScatProjToProj)
      {
        theCSMatrix = fAdjointCSMatricesForScatProjToProj[ind_model][ind_mat];
      }
      else
        theCSMatrix = fAdjointCSMatricesForProdToProj[ind_model][ind_mat];
      G4double CS = 0.;
      if(PrimEnergy > Tlow)
        CS = ComputeAdjointCS(PrimEnergy, theCSMatrix, Tlow);
      CS_Vs_Element.push_back(CS);
    }
    fLastAdjointCSVsModelsAndElements.push_back(CS_Vs_Element);
  }
 
  G4double CS = 0.;
  for(const auto& cs_vs_el : CS_Vs_Element)
  {
    // We could put the progressive sum of the CS instead of the CS of an
    // element itself
    CS += cs_vs_el;
  }
  return CS;
}

References G4VEmAdjointModel::AdjointCrossSection(), ComputeAdjointCS(), fAdjointCSMatricesForProdToProj, fAdjointCSMatricesForScatProjToProj, fAdjointModels, fCurrentCouple, fIndexOfAdjointEMModelInAction, fIsScatProjToProj, fLastAdjointCSVsModelsAndElements, G4VEmAdjointModel::GetApplyCutInRange(), G4Material::GetElement(), G4Element::GetIndex(), G4Material::GetIndex(), G4Material::GetNumberOfElements(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProj(), G4VEmAdjointModel::GetUseMatrix(), G4VEmAdjointModel::GetUseMatrixPerElement(), G4VEmAdjointModel::GetUseOnlyOneMatrixForAllElements(), G4Material::GetVecNbOfAtomsPerVolume(), and G4Element::GetZ().

Referenced by G4VEmAdjointModel::AdjointCrossSection(), ComputeAdjointCS(), ComputeTotalAdjointCS(), and SampleElementFromCSMatrices().

ComputeTotalAdjointCS()

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

Definition at line 757 of file G4AdjointCSManager.cc.

{
  G4double TotalCS = 0.;
 
  DefineCurrentMaterial(aCouple);
 
  std::vector<G4double> CS_Vs_Element;
  G4double CS;
  G4VEmAdjointModel* adjModel = nullptr;
  for(size_t i = 0; i < fAdjointModels.size(); ++i)
  {
    G4double Tlow = 0.;
    adjModel      = fAdjointModels[i];
    if(!adjModel->GetApplyCutInRange())
      Tlow = adjModel->GetLowEnergyLimit();
    else
    {
      G4ParticleDefinition* theDirSecondPartDef = GetForwardParticleEquivalent(
        adjModel->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 <= adjModel->GetHighEnergyLimit() &&
       Ekin >= adjModel->GetLowEnergyLimit())
    {
      if(aPartDef ==
         adjModel->GetAdjointEquivalentOfDirectPrimaryParticleDefinition())
      {
        CS = ComputeAdjointCS(fCurrentMaterial, adjModel, Ekin, Tlow, true,
                              CS_Vs_Element);
        TotalCS += CS;
        (*fSigmaTableForAdjointModelScatProjToProj[i])[fCurrentMatIndex]
          ->PutValue(fNbins, CS);
      }
      if(aPartDef ==
         adjModel->GetAdjointEquivalentOfDirectSecondaryParticleDefinition())
      {
        CS = ComputeAdjointCS(fCurrentMaterial, adjModel, Ekin, Tlow, false,
                              CS_Vs_Element);
        TotalCS += CS;
        (*fSigmaTableForAdjointModelProdToProj[i])[fCurrentMatIndex]->PutValue(
          fNbins, CS);
      }
    }
    else
    {
      (*fSigmaTableForAdjointModelScatProjToProj[i])[fCurrentMatIndex]
        ->PutValue(fNbins, 0.);
      (*fSigmaTableForAdjointModelProdToProj[i])[fCurrentMatIndex]->PutValue(
        fNbins, 0.);
    }
  }
  return TotalCS;
}

References ComputeAdjointCS(), DefineCurrentMaterial(), fAdjointModels, fCurrentMaterial, fCurrentMatIndex, fNbins, fSigmaTableForAdjointModelProdToProj, fSigmaTableForAdjointModelScatProjToProj, G4VEmAdjointModel::GetAdjointEquivalentOfDirectPrimaryParticleDefinition(), G4VEmAdjointModel::GetAdjointEquivalentOfDirectSecondaryParticleDefinition(), G4VEmAdjointModel::GetApplyCutInRange(), G4ProductionCutsTable::GetEnergyCutsVector(), GetForwardParticleEquivalent(), G4MaterialCutsCouple::GetIndex(), G4VEmAdjointModel::GetLowEnergyLimit(), G4ParticleDefinition::GetParticleName(), and G4ProductionCutsTable::GetProductionCutsTable().

Referenced by BuildTotalSigmaTables().

DefineCurrentMaterial()

void G4AdjointCSManager::DefineCurrentMaterial ( const G4MaterialCutsCouple *  couple )

private

Definition at line 1053 of file G4AdjointCSManager.cc.

{
  if(couple != fCurrentCouple)
  {
    fCurrentCouple          = const_cast<G4MaterialCutsCouple*>(couple);
    fCurrentMaterial        = const_cast<G4Material*>(couple->GetMaterial());
    fCurrentMatIndex        = couple->GetIndex();
    fLastCSCorrectionFactor = 1.;
  }
}

References fCurrentCouple, fCurrentMaterial, fCurrentMatIndex, fLastCSCorrectionFactor, G4MaterialCutsCouple::GetIndex(), and G4MaterialCutsCouple::GetMaterial().

Referenced by ComputeTotalAdjointCS(), GetAdjointSigma(), GetCrossSectionCorrection(), GetEminForTotalCS(), GetMaxAdjTotalCS(), GetMaxFwdTotalCS(), GetTotalAdjointCS(), and GetTotalForwardCS().

DefineCurrentParticle()

void G4AdjointCSManager::DefineCurrentParticle ( const G4ParticleDefinition *  aPartDef )

private

Definition at line 1066 of file G4AdjointCSManager.cc.

{
  static G4ParticleDefinition* currentParticleDef = nullptr;
 
  if(aPartDef != currentParticleDef)
  {
    currentParticleDef = const_cast<G4ParticleDefinition*>(aPartDef);
    fMassRatio         = 1.;
    if(aPartDef == fAdjIon)
      fMassRatio = proton_mass_c2 / aPartDef->GetPDGMass();
    fCurrentParticleIndex = 1000000;
    for(size_t i = 0; i < fAdjointParticlesInAction.size(); ++i)
    {
      if(aPartDef == fAdjointParticlesInAction[i])
        fCurrentParticleIndex = i;
    }
  }
}

References fAdjIon, fAdjointParticlesInAction, fCurrentParticleIndex, fMassRatio, G4ParticleDefinition::GetPDGMass(), and source.hepunit::proton_mass_c2.

Referenced by BuildTotalSigmaTables(), GetEminForTotalCS(), GetMaxAdjTotalCS(), GetMaxFwdTotalCS(), GetTotalAdjointCS(), and GetTotalForwardCS().

GetAdjointCSManager()

G4AdjointCSManager * G4AdjointCSManager::GetAdjointCSManager ( )

static

Definition at line 57 of file G4AdjointCSManager.cc.

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

References fInstance, and G4ThreadLocalSingleton< T >::Instance().

Referenced by G4AdjointIonIonisationModel::CorrectPostStepWeight(), G4AdjointPhotoElectricModel::CorrectPostStepWeight(), G4AdjointAlongStepWeightCorrection::G4AdjointAlongStepWeightCorrection(), G4AdjointForcedInteractionForGamma::G4AdjointForcedInteractionForGamma(), G4VAdjointReverseReaction::G4VAdjointReverseReaction(), G4VEmAdjointModel::G4VEmAdjointModel(), G4AdjointBremsstrahlungModel::Initialize(), G4AdjointComptonModel::RapidSampleSecondaries(), and G4AdjointhIonisationModel::RapidSampleSecondaries().

GetAdjointParticleEquivalent()

G4ParticleDefinition * G4AdjointCSManager::GetAdjointParticleEquivalent

(

G4ParticleDefinition *

theFwdPartDef

)

Definition at line 1023 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 == fFwdIon)
    return fAdjIon;
  return nullptr;
}

References G4AdjointElectron::AdjointElectron(), G4AdjointGamma::AdjointGamma(), G4AdjointProton::AdjointProton(), fAdjIon, fFwdIon, and G4ParticleDefinition::GetParticleName().

Referenced by RegisterEmProcess(), and RegisterEnergyLossProcess().

GetAdjointSigma()

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

Definition at line 459 of file G4AdjointCSManager.cc.

{
  DefineCurrentMaterial(aCouple);
  if(is_scat_proj_to_proj)
    return (((*fSigmaTableForAdjointModelScatProjToProj[index_model])
               [fCurrentMatIndex])->Value(Ekin_nuc));
  else
    return (
      ((*fSigmaTableForAdjointModelProdToProj[index_model])[fCurrentMatIndex])
        ->Value(Ekin_nuc));
}

References DefineCurrentMaterial(), fCurrentMatIndex, fSigmaTableForAdjointModelProdToProj, and fSigmaTableForAdjointModelScatProjToProj.

GetContinuousWeightCorrection()

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

Definition at line 557 of file G4AdjointCSManager.cc.

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

References fForwardCSUsed, fLastCSCorrectionFactor, GetTotalAdjointCS(), and GetTotalForwardCS().

Referenced by G4AdjointAlongStepWeightCorrection::AlongStepDoIt().

GetCrossSectionCorrection()

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

Definition at line 516 of file G4AdjointCSManager.cc.

{
  static G4double lastEkin = 0.;
  static G4ParticleDefinition* lastPartDef;
 
  G4double corr_fac = 1.;
  if(fForwardCSMode && aPartDef)
  {
    if(lastEkin != PreStepEkin || aPartDef != lastPartDef ||
       aCouple != fCurrentCouple)
    {
      DefineCurrentMaterial(aCouple);
      G4double preadjCS = GetTotalAdjointCS(aPartDef, PreStepEkin, aCouple);
      G4double prefwdCS = GetTotalForwardCS(aPartDef, PreStepEkin, aCouple);
      lastEkin          = PreStepEkin;
      lastPartDef       = aPartDef;
      if(prefwdCS > 0. && preadjCS > 0.)
      {
        fForwardCSUsed          = true;
        fLastCSCorrectionFactor = prefwdCS / preadjCS;
      }
      else
      {
        fForwardCSUsed          = false;
        fLastCSCorrectionFactor = 1.;
      }
    }
    corr_fac = fLastCSCorrectionFactor;
  }
  else
  {
    fForwardCSUsed          = false;
    fLastCSCorrectionFactor = 1.;
  }
  fwd_is_used = fForwardCSUsed;
  return corr_fac;
}

References DefineCurrentMaterial(), fCurrentCouple, fForwardCSMode, fForwardCSUsed, fLastCSCorrectionFactor, GetTotalAdjointCS(), and GetTotalForwardCS().

Referenced by G4VAdjointReverseReaction::GetMeanFreePath().

GetEminForTotalCS()

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

Definition at line 474 of file G4AdjointCSManager.cc.

{
  DefineCurrentMaterial(aCouple);
  DefineCurrentParticle(aPartDef);
  emin_adj = fEminForAdjSigmaTables[fCurrentParticleIndex][fCurrentMatIndex] /
             fMassRatio;
  emin_fwd = fEminForFwdSigmaTables[fCurrentParticleIndex][fCurrentMatIndex] /
             fMassRatio;
}

References DefineCurrentMaterial(), DefineCurrentParticle(), fCurrentMatIndex, fCurrentParticleIndex, fEminForAdjSigmaTables, fEminForFwdSigmaTables, and fMassRatio.

GetForwardParticleEquivalent()

G4ParticleDefinition * G4AdjointCSManager::GetForwardParticleEquivalent

(

G4ParticleDefinition *

theAdjPartDef

)

Definition at line 1038 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 == fAdjIon)
    return fFwdIon;
  return nullptr;
}

References G4Electron::Electron(), fAdjIon, fFwdIon, G4Gamma::Gamma(), G4ParticleDefinition::GetParticleName(), and G4Proton::Proton().

Referenced by ComputeTotalAdjointCS().

GetMaxAdjTotalCS()

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

Definition at line 502 of file G4AdjointCSManager.cc.

{
  DefineCurrentMaterial(aCouple);
  DefineCurrentParticle(aPartDef);
  e_sigma_max = fEkinofAdjSigmaMax[fCurrentParticleIndex][fCurrentMatIndex];
  sigma_max = ((*fTotalAdjSigmaTable[fCurrentParticleIndex])[fCurrentMatIndex])
                ->Value(e_sigma_max);
  e_sigma_max /= fMassRatio;
}

References DefineCurrentMaterial(), DefineCurrentParticle(), fCurrentMatIndex, fCurrentParticleIndex, fEkinofAdjSigmaMax, fMassRatio, and fTotalAdjSigmaTable.

GetMaxFwdTotalCS()

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

Definition at line 488 of file G4AdjointCSManager.cc.

{
  DefineCurrentMaterial(aCouple);
  DefineCurrentParticle(aPartDef);
  e_sigma_max = fEkinofFwdSigmaMax[fCurrentParticleIndex][fCurrentMatIndex];
  sigma_max = ((*fTotalFwdSigmaTable[fCurrentParticleIndex])[fCurrentMatIndex])
                ->Value(e_sigma_max);
  e_sigma_max /= fMassRatio;
}

References DefineCurrentMaterial(), DefineCurrentParticle(), fCurrentMatIndex, fCurrentParticleIndex, fEkinofFwdSigmaMax, fMassRatio, and fTotalFwdSigmaTable.

GetNbProcesses()

G4int G4AdjointCSManager::GetNbProcesses

(

)

GetPostStepWeightCorrection()

G4double G4AdjointCSManager::GetPostStepWeightCorrection

(

)

Definition at line 578 of file G4AdjointCSManager.cc.

{
  return 1. / fLastCSCorrectionFactor;
}

References fLastCSCorrectionFactor.

Referenced by G4VEmAdjointModel::CorrectPostStepWeight(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), G4AdjointPhotoElectricModel::CorrectPostStepWeight(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), and G4AdjointhIonisationModel::RapidSampleSecondaries().

GetTotalAdjointCS()

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

Definition at line 437 of file G4AdjointCSManager.cc.

{
  DefineCurrentMaterial(aCouple);
  DefineCurrentParticle(aPartDef);
  return (((*fTotalAdjSigmaTable[fCurrentParticleIndex])[fCurrentMatIndex])
            ->Value(Ekin * fMassRatio));
}

References DefineCurrentMaterial(), DefineCurrentParticle(), fCurrentMatIndex, fCurrentParticleIndex, fMassRatio, and fTotalAdjSigmaTable.

Referenced by G4AdjointForcedInteractionForGamma::AlongStepDoIt(), GetContinuousWeightCorrection(), GetCrossSectionCorrection(), and G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength().

GetTotalForwardCS()

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

Definition at line 448 of file G4AdjointCSManager.cc.

{
  DefineCurrentMaterial(aCouple);
  DefineCurrentParticle(aPartDef);
  return (((*fTotalFwdSigmaTable[fCurrentParticleIndex])[fCurrentMatIndex])
            ->Value(Ekin * fMassRatio));
}

References DefineCurrentMaterial(), DefineCurrentParticle(), fCurrentMatIndex, fCurrentParticleIndex, fMassRatio, and fTotalFwdSigmaTable.

Referenced by G4AdjointForcedInteractionForGamma::AlongStepDoIt(), GetContinuousWeightCorrection(), and GetCrossSectionCorrection().

RegisterAdjointParticle()

void G4AdjointCSManager::RegisterAdjointParticle

(

G4ParticleDefinition *

aPartDef

)

Definition at line 197 of file G4AdjointCSManager.cc.

{
  G4bool found = false;
  for(auto p : fAdjointParticlesInAction)
  {
    if(p->GetParticleName() == aPartDef->GetParticleName())
    {
      found = true;
    }
  }
  if(!found)
  {
    fForwardLossProcesses.push_back(new std::vector<G4VEnergyLossProcess*>());
    fTotalFwdSigmaTable.push_back(new G4PhysicsTable);
    fTotalAdjSigmaTable.push_back(new G4PhysicsTable);
    fForwardProcesses.push_back(new std::vector<G4VEmProcess*>());
    fAdjointParticlesInAction.push_back(aPartDef);
    fEminForFwdSigmaTables.push_back(std::vector<G4double>());
    fEminForAdjSigmaTables.push_back(std::vector<G4double>());
    fEkinofFwdSigmaMax.push_back(std::vector<G4double>());
    fEkinofAdjSigmaMax.push_back(std::vector<G4double>());
  }
}

References fAdjointParticlesInAction, fEkinofAdjSigmaMax, fEkinofFwdSigmaMax, fEminForAdjSigmaTables, fEminForFwdSigmaTables, fForwardLossProcesses, fForwardProcesses, fTotalAdjSigmaTable, fTotalFwdSigmaTable, and G4ParticleDefinition::GetParticleName().

Referenced by G4AdjointCSManager(), RegisterEmProcess(), and RegisterEnergyLossProcess().

RegisterEmAdjointModel()

size_t G4AdjointCSManager::RegisterEmAdjointModel

(

G4VEmAdjointModel *

aModel

)

Definition at line 150 of file G4AdjointCSManager.cc.

{
  fAdjointModels.push_back(aModel);
  fSigmaTableForAdjointModelScatProjToProj.push_back(new G4PhysicsTable);
  fSigmaTableForAdjointModelProdToProj.push_back(new G4PhysicsTable);
  return fAdjointModels.size() - 1;
}

References fAdjointModels, fSigmaTableForAdjointModelProdToProj, and fSigmaTableForAdjointModelScatProjToProj.

Referenced by G4VEmAdjointModel::G4VEmAdjointModel().

RegisterEmProcess()

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

Definition at line 159 of file G4AdjointCSManager.cc.

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

References fAdjointParticlesInAction, fForwardProcesses, GetAdjointParticleEquivalent(), G4ParticleDefinition::GetParticleName(), and RegisterAdjointParticle().

RegisterEnergyLossProcess()

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

Definition at line 178 of file G4AdjointCSManager.cc.

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

References fAdjointParticlesInAction, fForwardLossProcesses, GetAdjointParticleEquivalent(), G4ParticleDefinition::GetParticleName(), and RegisterAdjointParticle().

SampleElementFromCSMatrices()

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

Definition at line 734 of file G4AdjointCSManager.cc.

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

References ComputeAdjointCS(), G4UniformRand, and G4Material::GetElement().

SetFwdCrossSectionMode()

void G4AdjointCSManager::SetFwdCrossSectionMode ( G4bool  aBool )

inline

Definition at line 117 of file G4AdjointCSManager.hh.

{ fForwardCSMode = aBool; }

References fForwardCSMode.

SetIon()

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

inline

Definition at line 152 of file G4AdjointCSManager.hh.

  {
    fAdjIon = adjIon;
    fFwdIon = fwdIon;
  }

References fAdjIon, and fFwdIon.

Friends And Related Function Documentation

G4ThreadLocalSingleton< G4AdjointCSManager >

friend class G4ThreadLocalSingleton< G4AdjointCSManager >

friend

Definition at line 1 of file G4AdjointCSManager.hh.

Field Documentation

fAdjIon

G4ParticleDefinition* G4AdjointCSManager::fAdjIon = nullptr

private

Definition at line 184 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), DefineCurrentParticle(), GetAdjointParticleEquivalent(), GetForwardParticleEquivalent(), and SetIon().

fAdjointCSMatricesForProdToProj

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

private

Definition at line 194 of file G4AdjointCSManager.hh.

Referenced by BuildCrossSectionMatrices(), ComputeAdjointCS(), and ~G4AdjointCSManager().

fAdjointCSMatricesForScatProjToProj

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

private

Definition at line 192 of file G4AdjointCSManager.hh.

Referenced by BuildCrossSectionMatrices(), ComputeAdjointCS(), and ~G4AdjointCSManager().

fAdjointModels

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

private

Definition at line 196 of file G4AdjointCSManager.hh.

Referenced by BuildCrossSectionMatrices(), BuildTotalSigmaTables(), ComputeAdjointCS(), ComputeTotalAdjointCS(), RegisterEmAdjointModel(), and ~G4AdjointCSManager().

fAdjointParticlesInAction

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

private

Definition at line 222 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), DefineCurrentParticle(), RegisterAdjointParticle(), RegisterEmProcess(), and RegisterEnergyLossProcess().

fCSMatricesBuilt

G4bool G4AdjointCSManager::fCSMatricesBuilt = false

private

Definition at line 230 of file G4AdjointCSManager.hh.

Referenced by BuildCrossSectionMatrices().

fCurrentCouple

G4MaterialCutsCouple* G4AdjointCSManager::fCurrentCouple = nullptr

private

Definition at line 187 of file G4AdjointCSManager.hh.

Referenced by ComputeAdjointCS(), DefineCurrentMaterial(), and GetCrossSectionCorrection().

fCurrentMaterial

G4Material* G4AdjointCSManager::fCurrentMaterial = nullptr

private

Definition at line 188 of file G4AdjointCSManager.hh.

Referenced by ComputeTotalAdjointCS(), and DefineCurrentMaterial().

fCurrentMatIndex

size_t G4AdjointCSManager::fCurrentMatIndex = 0

private

Definition at line 228 of file G4AdjointCSManager.hh.

Referenced by ComputeTotalAdjointCS(), DefineCurrentMaterial(), GetAdjointSigma(), GetEminForTotalCS(), GetMaxAdjTotalCS(), GetMaxFwdTotalCS(), GetTotalAdjointCS(), and GetTotalForwardCS().

fCurrentParticleIndex

size_t G4AdjointCSManager::fCurrentParticleIndex = 0

private

Definition at line 227 of file G4AdjointCSManager.hh.

Referenced by DefineCurrentParticle(), GetEminForTotalCS(), GetMaxAdjTotalCS(), GetMaxFwdTotalCS(), GetTotalAdjointCS(), and GetTotalForwardCS().

fEkinofAdjSigmaMax

std::vector<std::vector<G4double> > G4AdjointCSManager::fEkinofAdjSigmaMax

private

Definition at line 214 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), GetMaxAdjTotalCS(), and RegisterAdjointParticle().

fEkinofFwdSigmaMax

std::vector<std::vector<G4double> > G4AdjointCSManager::fEkinofFwdSigmaMax

private

Definition at line 213 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), GetMaxFwdTotalCS(), and RegisterAdjointParticle().

fEminForAdjSigmaTables

std::vector<std::vector<G4double> > G4AdjointCSManager::fEminForAdjSigmaTables

private

Definition at line 212 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), GetEminForTotalCS(), and RegisterAdjointParticle().

fEminForFwdSigmaTables

std::vector<std::vector<G4double> > G4AdjointCSManager::fEminForFwdSigmaTables

private

Definition at line 211 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), GetEminForTotalCS(), and RegisterAdjointParticle().

fForwardCSMode

G4bool G4AdjointCSManager::fForwardCSMode = true

private

Definition at line 233 of file G4AdjointCSManager.hh.

Referenced by GetCrossSectionCorrection(), and SetFwdCrossSectionMode().

fForwardCSUsed

G4bool G4AdjointCSManager::fForwardCSUsed = true

private

Definition at line 232 of file G4AdjointCSManager.hh.

Referenced by GetContinuousWeightCorrection(), and GetCrossSectionCorrection().

fForwardLossProcesses

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

private

Definition at line 219 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), RegisterAdjointParticle(), RegisterEnergyLossProcess(), and ~G4AdjointCSManager().

fForwardProcesses

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

private

Definition at line 218 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), RegisterAdjointParticle(), RegisterEmProcess(), and ~G4AdjointCSManager().

fFwdIon

G4ParticleDefinition* G4AdjointCSManager::fFwdIon = nullptr

private

Definition at line 185 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), GetAdjointParticleEquivalent(), GetForwardParticleEquivalent(), and SetIon().

fIndexOfAdjointEMModelInAction

std::vector<size_t> G4AdjointCSManager::fIndexOfAdjointEMModelInAction

private

Definition at line 198 of file G4AdjointCSManager.hh.

Referenced by ComputeAdjointCS().

fInstance

G4ThreadLocal G4AdjointCSManager * G4AdjointCSManager::fInstance = nullptr

staticprivate

Definition at line 181 of file G4AdjointCSManager.hh.

Referenced by GetAdjointCSManager().

fIsScatProjToProj

std::vector<G4bool> G4AdjointCSManager::fIsScatProjToProj

private

Definition at line 199 of file G4AdjointCSManager.hh.

Referenced by ComputeAdjointCS().

fLastAdjointCSVsModelsAndElements

std::vector<std::vector<G4double> > G4AdjointCSManager::fLastAdjointCSVsModelsAndElements

private

Definition at line 200 of file G4AdjointCSManager.hh.

Referenced by ComputeAdjointCS().

fLastCSCorrectionFactor

G4double G4AdjointCSManager::fLastCSCorrectionFactor = 1.

private

Definition at line 225 of file G4AdjointCSManager.hh.

Referenced by DefineCurrentMaterial(), GetContinuousWeightCorrection(), GetCrossSectionCorrection(), and GetPostStepWeightCorrection().

fMassRatio

G4double G4AdjointCSManager::fMassRatio = 1.

private

Definition at line 224 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), DefineCurrentParticle(), GetEminForTotalCS(), GetMaxAdjTotalCS(), GetMaxFwdTotalCS(), GetTotalAdjointCS(), and GetTotalForwardCS().

fNbins

constexpr G4int G4AdjointCSManager::fNbins = 320

staticconstexprprivate

Definition at line 179 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), and ComputeTotalAdjointCS().

fSigmaTableBuilt

G4bool G4AdjointCSManager::fSigmaTableBuilt = false

private

Definition at line 231 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables().

fSigmaTableForAdjointModelProdToProj

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

private

Definition at line 209 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), ComputeTotalAdjointCS(), GetAdjointSigma(), RegisterEmAdjointModel(), and ~G4AdjointCSManager().

fSigmaTableForAdjointModelScatProjToProj

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

private

Definition at line 208 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), ComputeTotalAdjointCS(), GetAdjointSigma(), RegisterEmAdjointModel(), and ~G4AdjointCSManager().

fTmax

constexpr G4double G4AdjointCSManager::fTmax = 100. * CLHEP::TeV

staticconstexprprivate

Definition at line 176 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables().

fTmin

constexpr G4double G4AdjointCSManager::fTmin = 0.1 * CLHEP::keV

staticconstexprprivate

Definition at line 175 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables().

fTotalAdjSigmaTable

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

private

Definition at line 205 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), GetMaxAdjTotalCS(), GetTotalAdjointCS(), RegisterAdjointParticle(), and ~G4AdjointCSManager().

fTotalFwdSigmaTable

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

private

Definition at line 204 of file G4AdjointCSManager.hh.

Referenced by BuildTotalSigmaTables(), GetMaxFwdTotalCS(), GetTotalForwardCS(), RegisterAdjointParticle(), and ~G4AdjointCSManager().

---

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

• source/processes/electromagnetic/adjoint/include/G4AdjointCSManager.hh
• source/processes/electromagnetic/adjoint/src/G4AdjointCSManager.cc