G4AdjointCSManager Class Reference

#include <G4AdjointCSManager.hh>

Public Member Functions
	~G4AdjointCSManager ()
G4int	GetNbProcesses ()
std::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, std::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)
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 isScatProjToProj, std::vector< G4double > &AdjointCS_for_each_element)
G4Element *	SampleElementFromCSMatrices (G4Material *aMaterial, G4VEmAdjointModel *aModel, G4double PrimEnergy, G4double Tcut, G4bool isScatProjToProj)
G4double	ComputeTotalAdjointCS (const G4MaterialCutsCouple *aMatCutCouple, G4ParticleDefinition *aPart, G4double PrimEnergy)
G4ParticleDefinition *	GetAdjointParticleEquivalent (G4ParticleDefinition *theFwdPartDef)
G4ParticleDefinition *	GetForwardParticleEquivalent (G4ParticleDefinition *theAdjPartDef)
void	SetIon (G4ParticleDefinition *adjIon, G4ParticleDefinition *fwdIon)

Static Public Member Functions
static G4AdjointCSManager *	GetAdjointCSManager ()

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();
}

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;
}

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

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(std::size_t i = 0; i < fAdjointModels.size(); ++i)
  {
    fSigmaTableForAdjointModelScatProjToProj[i]->clearAndDestroy();
    fSigmaTableForAdjointModelProdToProj[i]->clearAndDestroy();
    for(std::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(std::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(std::size_t j = 0; j < theCoupleTable->GetTableSize(); ++j)
    {
      const G4MaterialCutsCouple* couple =
        theCoupleTable->GetMaterialCutsCouple((G4int)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(std::size_t l = 0; l < fNbins; ++l)
      {
        G4double totCS = 0.;
        G4double e     = aVector->Energy(l);
        for(std::size_t k = 0; k < fForwardProcesses[i]->size(); ++k)
        {
          totCS += (*fForwardProcesses[i])[k]->GetCrossSection(e, couple);
        }
        for(std::size_t k = 0; k < fForwardLossProcesses[i]->size(); ++k)
        {
          if(thePartDef == fAdjIon)
          {  // e is considered already as the scaled energy
            std::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(std::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;
}

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

ComputeAdjointCS()

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;
  }
 
  std::size_t ind = 0;
  if(!need_to_compute)
  {
    need_to_compute = true;
    for(std::size_t i = 0; i < fIndexOfAdjointEMModelInAction.size(); ++i)
    {
      std::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)
  {
    std::size_t ind_model = 0;
    for(std::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())
    {
      std::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(G4int i = 0; i < (G4int)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(G4int i = 0; i < (G4int)n_el; ++i)
        {
          std::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
    {
      std::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;
}

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(std::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());
      std::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;
}

Referenced by BuildTotalSigmaTables().

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;
}

Referenced by G4AdjointIonIonisationModel::CorrectPostStepWeight(), G4AdjointPhotoElectricModel::CorrectPostStepWeight(), G4AdjointAlongStepWeightCorrection::G4AdjointAlongStepWeightCorrection(), G4AdjointForcedInteractionForGamma::G4AdjointForcedInteractionForGamma(), G4VAdjointReverseReaction::G4VAdjointReverseReaction(), G4VEmAdjointModel::G4VEmAdjointModel(), 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;
}

Referenced by RegisterEmProcess(), and RegisterEnergyLossProcess().

GetAdjointSigma()

G4double G4AdjointCSManager::GetAdjointSigma	(	G4double	Ekin_nuc,
		std::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));
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

GetNbProcesses()

G4int G4AdjointCSManager::GetNbProcesses

(

)

GetPostStepWeightCorrection()

G4double G4AdjointCSManager::GetPostStepWeightCorrection

(

)

Definition at line 578 of file G4AdjointCSManager.cc.

{
  return 1. / 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));
}

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));
}

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>());
  }
}

Referenced by RegisterEmProcess(), and RegisterEnergyLossProcess().

RegisterEmAdjointModel()

std::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;
}

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(std::size_t i = 0; i < fAdjointParticlesInAction.size(); ++i)
    {
      if(anAdjPartDef->GetParticleName() ==
         fAdjointParticlesInAction[i]->GetParticleName())
          fForwardProcesses[i]->push_back(aProcess);
    }
  }
}

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(std::size_t i = 0; i < fAdjointParticlesInAction.size(); ++i)
    {
      if(anAdjPartDef->GetParticleName() ==
         fAdjointParticlesInAction[i]->GetParticleName())
                                fForwardLossProcesses[i]->push_back(aProcess);
 
    }
  }
}

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.;
  std::size_t ind     = 0;
  for(std::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((G4int)ind));
}

SetFwdCrossSectionMode()

void G4AdjointCSManager::SetFwdCrossSectionMode ( G4bool  aBool )

inline

Definition at line 117 of file G4AdjointCSManager.hh.

{ fForwardCSMode = aBool; }

SetIon()

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

inline

Definition at line 152 of file G4AdjointCSManager.hh.

  {
    fAdjIon = adjIon;
    fFwdIon = fwdIon;
  }

Friends And Related Function Documentation

G4ThreadLocalSingleton< G4AdjointCSManager >

friend class G4ThreadLocalSingleton< G4AdjointCSManager >

friend

Definition at line 1 of file G4AdjointCSManager.hh.

---

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

• G4AdjointCSManager.hh
• G4AdjointCSManager.cc