#include <G4AdjointPrimaryGeneratorAction.hh>

Inheritance diagram for G4AdjointPrimaryGeneratorAction:

Public Member Functions
void	ConsiderParticleAsPrimary (const G4String &particle_name)

	G4AdjointPrimaryGeneratorAction ()

	G4AdjointPrimaryGeneratorAction (const G4AdjointPrimaryGeneratorAction &)=delete

void	GeneratePrimaries (G4Event *)

G4ParticleDefinition *	GetLastGeneratedFwdPrimaryParticle ()

std::vector< G4ParticleDefinition * > *	GetListOfPrimaryFwdParticles ()

size_t	GetNbOfAdjointPrimaryTypes ()

const G4String &	GetPrimaryIonName ()

void	NeglectParticleAsPrimary (const G4String &particle_name)

G4AdjointPrimaryGeneratorAction &	operator= (const G4AdjointPrimaryGeneratorAction &)=delete

void	SetAdjointPrimarySourceOnAnExtSurfaceOfAVolume (const G4String &volume_name)

void	SetEmax (G4double val)

void	SetEmaxIon (G4double val)

void	SetEmin (G4double val)

void	SetEminIon (G4double val)

void	SetNbAdjointPrimaryElectronsPerEvent (G4int nb)

void	SetNbAdjointPrimaryGammasPerEvent (G4int nb)

void	SetNbPrimaryFwdGammasPerEvent (G4int nb)

void	SetPrimaryIon (G4ParticleDefinition adjointIon, G4ParticleDefinition fwdIon)

void	SetRndmFlag (const G4String &val)

void	SetSphericalAdjointPrimarySource (G4double radius, G4ThreeVector pos)

void	UpdateListOfPrimaryParticles ()

	~G4AdjointPrimaryGeneratorAction ()

Private Member Functions
G4double	ComputeEnergyDistWeight (G4double energy, G4double E1, G4double E2)

Private Attributes
G4ParticleDefinition *	adj_ion = nullptr

G4ThreeVector	center_spherical_source

G4ThreeVector	direction

G4double	Emax = 0.0

G4double	EmaxIon = 0.0

G4double	Emin = 0.0

G4double	EminIon = 0.0

G4ParticleDefinition *	fwd_ion = nullptr

std::size_t	index_particle = 100000

G4String	ion_name = "not_defined"

std::vector< G4ParticleDefinition * >	ListOfPrimaryAdjParticles

std::vector< G4ParticleDefinition * >	ListOfPrimaryFwdParticles

G4int	nb_adj_primary_electrons_per_event = 1

G4int	nb_adj_primary_gammas_per_event = 1

G4int	nb_fwd_gammas_per_event = 1

G4ThreeVector	p

G4ThreeVector	pos

std::map< G4String, G4bool >	PrimariesConsideredInAdjointSim

G4double	radius_spherical_source = 0.0

G4String	rndmFlag

G4AdjointPrimaryGenerator *	theAdjointPrimaryGenerator = nullptr

G4String	type_of_adjoint_source

Detailed Description

Definition at line 80 of file G4AdjointPrimaryGeneratorAction.hh.

Constructor & Destructor Documentation

◆ G4AdjointPrimaryGeneratorAction() [1/2]

G4AdjointPrimaryGeneratorAction::G4AdjointPrimaryGeneratorAction ( )

Definition at line 48 of file G4AdjointPrimaryGeneratorAction.cc.

{
  theAdjointPrimaryGenerator = new G4AdjointPrimaryGenerator();
 
  PrimariesConsideredInAdjointSim[G4String("e-")]     = false;
  PrimariesConsideredInAdjointSim[G4String("gamma")]  = false;
  PrimariesConsideredInAdjointSim[G4String("proton")] = false;
  PrimariesConsideredInAdjointSim[G4String("ion")]    = false;
 
  ListOfPrimaryFwdParticles.clear();
  ListOfPrimaryAdjParticles.clear();
}

References ListOfPrimaryAdjParticles, ListOfPrimaryFwdParticles, PrimariesConsideredInAdjointSim, and theAdjointPrimaryGenerator.

◆ ~G4AdjointPrimaryGeneratorAction()

G4AdjointPrimaryGeneratorAction::~G4AdjointPrimaryGeneratorAction ( )

Definition at line 63 of file G4AdjointPrimaryGeneratorAction.cc.

{
  delete theAdjointPrimaryGenerator;
}

References theAdjointPrimaryGenerator.

◆ G4AdjointPrimaryGeneratorAction() [2/2]

G4AdjointPrimaryGeneratorAction::G4AdjointPrimaryGeneratorAction ( const G4AdjointPrimaryGeneratorAction & )

delete

Member Function Documentation

◆ ComputeEnergyDistWeight()

G4double G4AdjointPrimaryGeneratorAction::ComputeEnergyDistWeight	(	G4double	energy,
		G4double	E1,
		G4double	E2
	)

private

Definition at line 225 of file G4AdjointPrimaryGeneratorAction.cc.

{
  // We generate N numbers of primaries with  a 1/E energy law distribution.
  // We have therefore  an energy distribution function
  //   f(E)=C/E  (1)
  // with   C a constant that is such that
  //   N=Integral(f(E),E1,E2)=C.std::log(E2/E1)  (2)
  // Therefore from (2) we get
  //   C=N/ std::log(E2/E1) (3)
  // and
  //   f(E)=N/ std::log(E2/E1)/E (4)
  // For the adjoint simulation we need a energy distribution  f'(E)=1..
  // To get that we need therefore to apply a weight to the primary
  //   W=1/f(E)=E*std::log(E2/E1)/N
  //
  return std::log(E2 / E1) * E /
         G4AdjointSimManager::GetInstance()->GetNbEvtOfLastRun();
}

References G4AdjointSimManager::GetInstance(), and G4AdjointSimManager::GetNbEvtOfLastRun().

Referenced by GeneratePrimaries().

◆ ConsiderParticleAsPrimary()

void G4AdjointPrimaryGeneratorAction::ConsiderParticleAsPrimary ( const G4String & particle_name )

Definition at line 270 of file G4AdjointPrimaryGeneratorAction.cc.

{
  if(PrimariesConsideredInAdjointSim.find(particle_name) !=
     PrimariesConsideredInAdjointSim.end())
  {
    PrimariesConsideredInAdjointSim[particle_name] = true;
  }
  UpdateListOfPrimaryParticles();
}

References PrimariesConsideredInAdjointSim, and UpdateListOfPrimaryParticles().

Referenced by G4AdjointSimManager::ConsiderParticleAsPrimary().

◆ GeneratePrimaries()

void G4AdjointPrimaryGeneratorAction::GeneratePrimaries ( G4Event * anEvent )

virtual

Implements G4VUserPrimaryGeneratorAction.

Definition at line 70 of file G4AdjointPrimaryGeneratorAction.cc.

{
  G4int evt_id   = anEvent->GetEventID();
  std::size_t n  = ListOfPrimaryAdjParticles.size();
  index_particle = std::size_t(evt_id) - n * (std::size_t(evt_id) / n);
 
  G4double E1 = Emin;
  G4double E2 = Emax;
  if(ListOfPrimaryAdjParticles[index_particle] == nullptr)
    UpdateListOfPrimaryParticles();  // ion has not been created yet
 
  if(ListOfPrimaryAdjParticles[index_particle]->GetParticleName() ==
     "adj_proton")
  {
    E1 = EminIon;
    E2 = EmaxIon;
  }
  if(ListOfPrimaryAdjParticles[index_particle]->GetParticleType() ==
     "adjoint_nucleus")
  {
    G4int A = ListOfPrimaryAdjParticles[index_particle]->GetAtomicMass();
    E1      = EminIon * A;
    E2      = EmaxIon * A;
  }
  // Generate first the forwrad primaries
  theAdjointPrimaryGenerator->GenerateFwdPrimaryVertex(
    anEvent, ListOfPrimaryFwdParticles[index_particle], E1, E2);
  G4PrimaryVertex* fwdPrimVertex = anEvent->GetPrimaryVertex();
 
  p             = fwdPrimVertex->GetPrimary()->GetMomentum();
  pos           = fwdPrimVertex->GetPosition();
  G4double pmag = p.mag();
  G4double m0   = ListOfPrimaryFwdParticles[index_particle]->GetPDGMass();
  G4double ekin = std::sqrt(m0 * m0 + pmag * pmag) - m0;
 
  G4double weight_correction = 1.;
  // For gamma generate the particle along the backward ray
  G4ThreeVector dir = -p / p.mag();
 
  weight_correction = 1.;
 
  if(ListOfPrimaryFwdParticles[index_particle] == G4Gamma::Gamma() &&
     nb_fwd_gammas_per_event > 1)
  {
    G4double weight = (1. / nb_fwd_gammas_per_event);
    fwdPrimVertex->SetWeight(weight);
    for(G4int i = 0; i < nb_fwd_gammas_per_event - 1; ++i)
    {
      G4PrimaryVertex* newFwdPrimVertex = new G4PrimaryVertex();
      newFwdPrimVertex->SetPosition(pos.x(), pos.y(), pos.z());
      newFwdPrimVertex->SetT0(0.);
      G4PrimaryParticle* aPrimParticle = new G4PrimaryParticle(
        ListOfPrimaryFwdParticles[index_particle], p.x(), p.y(), p.z());
      newFwdPrimVertex->SetPrimary(aPrimParticle);
      newFwdPrimVertex->SetWeight(weight);
      anEvent->AddPrimaryVertex(newFwdPrimVertex);
    }
  }
 
  // Now generate the adjoint primaries
  G4PrimaryVertex* adjPrimVertex = new G4PrimaryVertex();
  adjPrimVertex->SetPosition(pos.x(), pos.y(), pos.z());
  adjPrimVertex->SetT0(0.);
  G4PrimaryParticle* aPrimParticle = new G4PrimaryParticle(
    ListOfPrimaryAdjParticles[index_particle], -p.x(), -p.y(), -p.z());
 
  adjPrimVertex->SetPrimary(aPrimParticle);
  anEvent->AddPrimaryVertex(adjPrimVertex);
 
  // The factor pi is to normalise the weight to the directional flux
  G4double adjoint_source_area =
    G4AdjointSimManager::GetInstance()->GetAdjointSourceArea();
  G4double adjoint_weight = weight_correction *
                            ComputeEnergyDistWeight(ekin, E1, E2) *
                            adjoint_source_area * pi;
  // if (ListOfPrimaryFwdParticles[index_particle]  ==G4Gamma::Gamma())
  // adjoint_weight = adjoint_weight/3.;
  if(ListOfPrimaryAdjParticles[index_particle]->GetParticleName() ==
     "adj_gamma")
  {
    // The weight will be corrected at the end of the track if splitted tracks
    // are used
    adjoint_weight = adjoint_weight / nb_adj_primary_gammas_per_event;
    for(G4int i = 0; i < nb_adj_primary_gammas_per_event - 1; ++i)
    {
      G4PrimaryVertex* newAdjPrimVertex = new G4PrimaryVertex();
      newAdjPrimVertex->SetPosition(pos.x(), pos.y(), pos.z());
      newAdjPrimVertex->SetT0(0.);
      aPrimParticle = new G4PrimaryParticle(
        ListOfPrimaryAdjParticles[index_particle], -p.x(), -p.y(), -p.z());
      newAdjPrimVertex->SetPrimary(aPrimParticle);
      newAdjPrimVertex->SetWeight(adjoint_weight);
      anEvent->AddPrimaryVertex(newAdjPrimVertex);
    }
  }
  else if(ListOfPrimaryAdjParticles[index_particle]->GetParticleName() ==
          "adj_electron")
  {
    // The weight will be corrected at the end of the track if splitted tracks
    // are used
    adjoint_weight = adjoint_weight / nb_adj_primary_electrons_per_event;
    for(G4int i = 0; i < nb_adj_primary_electrons_per_event - 1; ++i)
    {
      G4PrimaryVertex* newAdjPrimVertex = new G4PrimaryVertex();
      newAdjPrimVertex->SetPosition(pos.x(), pos.y(), pos.z());
      newAdjPrimVertex->SetT0(0.);
      aPrimParticle = new G4PrimaryParticle(
        ListOfPrimaryAdjParticles[index_particle], -p.x(), -p.y(), -p.z());
      newAdjPrimVertex->SetPrimary(aPrimParticle);
      newAdjPrimVertex->SetWeight(adjoint_weight);
      anEvent->AddPrimaryVertex(newAdjPrimVertex);
    }
  }
  adjPrimVertex->SetWeight(adjoint_weight);
 
  // Call some methods of G4AdjointSimManager
  G4AdjointSimManager::GetInstance()->SetAdjointTrackingMode(true);
  G4AdjointSimManager::GetInstance()->ClearEndOfAdjointTrackInfoVectors();
  G4AdjointSimManager::GetInstance()
    ->ResetDidOneAdjPartReachExtSourceDuringEvent();
 
}

References A, G4Event::AddPrimaryVertex(), G4AdjointSimManager::ClearEndOfAdjointTrackInfoVectors(), ComputeEnergyDistWeight(), Emax, EmaxIon, Emin, EminIon, G4Gamma::Gamma(), G4AdjointPrimaryGenerator::GenerateFwdPrimaryVertex(), G4AdjointSimManager::GetAdjointSourceArea(), G4Event::GetEventID(), G4AdjointSimManager::GetInstance(), G4PrimaryParticle::GetMomentum(), G4PrimaryVertex::GetPosition(), G4PrimaryVertex::GetPrimary(), G4Event::GetPrimaryVertex(), index_particle, ListOfPrimaryAdjParticles, ListOfPrimaryFwdParticles, CLHEP::Hep3Vector::mag(), CLHEP::detail::n, nb_adj_primary_electrons_per_event, nb_adj_primary_gammas_per_event, nb_fwd_gammas_per_event, p, pi, pos, G4AdjointSimManager::ResetDidOneAdjPartReachExtSourceDuringEvent(), G4AdjointSimManager::SetAdjointTrackingMode(), G4PrimaryVertex::SetPosition(), G4PrimaryVertex::SetPrimary(), G4PrimaryVertex::SetT0(), G4PrimaryVertex::SetWeight(), theAdjointPrimaryGenerator, UpdateListOfPrimaryParticles(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ GetLastGeneratedFwdPrimaryParticle()

G4ParticleDefinition * G4AdjointPrimaryGeneratorAction::GetLastGeneratedFwdPrimaryParticle ( )

inline

Definition at line 135 of file G4AdjointPrimaryGeneratorAction.hh.

    {
      return ListOfPrimaryFwdParticles[index_particle];
    }

References index_particle, and ListOfPrimaryFwdParticles.

Referenced by G4AdjointSimManager::GetLastGeneratedFwdPrimaryParticle().

◆ GetListOfPrimaryFwdParticles()

std::vector< G4ParticleDefinition * > * G4AdjointPrimaryGeneratorAction::GetListOfPrimaryFwdParticles ( )

inline

Definition at line 115 of file G4AdjointPrimaryGeneratorAction.hh.

    {
      return &ListOfPrimaryFwdParticles;
    }

References ListOfPrimaryFwdParticles.

Referenced by G4AdjointSimManager::G4AdjointSimManager(), G4AdjointSimManager::GetListOfPrimaryFwdParticles(), G4AdjointSimManager::GetNbOfPrimaryFwdParticles(), and G4AdjointSimManager::RegisterAtEndOfAdjointTrack().

◆ GetNbOfAdjointPrimaryTypes()

size_t G4AdjointPrimaryGeneratorAction::GetNbOfAdjointPrimaryTypes ( )

inline

Definition at line 111 of file G4AdjointPrimaryGeneratorAction.hh.

    {
      return ListOfPrimaryAdjParticles.size();
    }

References ListOfPrimaryAdjParticles.

Referenced by G4AdjointSimManager::RunAdjointSimulation().

◆ GetPrimaryIonName()

const G4String & G4AdjointPrimaryGeneratorAction::GetPrimaryIonName ( )

inline

Definition at line 119 of file G4AdjointPrimaryGeneratorAction.hh.

    {
      return ion_name;
    }

References ion_name.

Referenced by G4AdjointSimManager::GetPrimaryIonName().

◆ NeglectParticleAsPrimary()

void G4AdjointPrimaryGeneratorAction::NeglectParticleAsPrimary ( const G4String & particle_name )

Definition at line 283 of file G4AdjointPrimaryGeneratorAction.cc.

{
  if(PrimariesConsideredInAdjointSim.find(particle_name) !=
     PrimariesConsideredInAdjointSim.end())
  {
    PrimariesConsideredInAdjointSim[particle_name] = false;
  }
  UpdateListOfPrimaryParticles();
}

References PrimariesConsideredInAdjointSim, and UpdateListOfPrimaryParticles().

Referenced by G4AdjointSimManager::NeglectParticleAsPrimary().

◆ operator=()

G4AdjointPrimaryGeneratorAction & G4AdjointPrimaryGeneratorAction::operator= ( const G4AdjointPrimaryGeneratorAction & )

delete

◆ SetAdjointPrimarySourceOnAnExtSurfaceOfAVolume()

void G4AdjointPrimaryGeneratorAction::SetAdjointPrimarySourceOnAnExtSurfaceOfAVolume ( const G4String & volume_name )

Definition at line 260 of file G4AdjointPrimaryGeneratorAction.cc.

{
  type_of_adjoint_source = "ExternalSurfaceOfAVolume";
  theAdjointPrimaryGenerator->SetAdjointPrimarySourceOnAnExtSurfaceOfAVolume(
    volume_name);
}

References G4AdjointPrimaryGenerator::SetAdjointPrimarySourceOnAnExtSurfaceOfAVolume(), theAdjointPrimaryGenerator, and type_of_adjoint_source.

Referenced by G4AdjointSimManager::DefineAdjointSourceOnTheExtSurfaceOfAVolume().

◆ SetEmax()

void G4AdjointPrimaryGeneratorAction::SetEmax ( G4double val )

Definition at line 203 of file G4AdjointPrimaryGeneratorAction.cc.

{
  Emax    = val;
  EmaxIon = val;
}

References Emax, and EmaxIon.

Referenced by G4AdjointSimManager::SetAdjointSourceEmax().

◆ SetEmaxIon()

void G4AdjointPrimaryGeneratorAction::SetEmaxIon ( G4double val )

Definition at line 218 of file G4AdjointPrimaryGeneratorAction.cc.

{
  EmaxIon = val;
}

References EmaxIon.

◆ SetEmin()

void G4AdjointPrimaryGeneratorAction::SetEmin ( G4double val )

Definition at line 195 of file G4AdjointPrimaryGeneratorAction.cc.

{
  Emin    = val;
  EminIon = val;
}

References Emin, and EminIon.

Referenced by G4AdjointSimManager::SetAdjointSourceEmin().

◆ SetEminIon()

void G4AdjointPrimaryGeneratorAction::SetEminIon ( G4double val )

Definition at line 211 of file G4AdjointPrimaryGeneratorAction.cc.

{
  EminIon = val;
}

References EminIon.

◆ SetNbAdjointPrimaryElectronsPerEvent()

void G4AdjointPrimaryGeneratorAction::SetNbAdjointPrimaryElectronsPerEvent ( G4int nb )

inline

Definition at line 131 of file G4AdjointPrimaryGeneratorAction.hh.

    {
      nb_adj_primary_electrons_per_event = nb;
    }

References nb_adj_primary_electrons_per_event.

Referenced by G4AdjointSimManager::SetNbAdjointPrimaryElectronsPerEvent().

◆ SetNbAdjointPrimaryGammasPerEvent()

void G4AdjointPrimaryGeneratorAction::SetNbAdjointPrimaryGammasPerEvent ( G4int nb )

inline

Definition at line 127 of file G4AdjointPrimaryGeneratorAction.hh.

    {
      nb_adj_primary_gammas_per_event = nb;
    }

References nb_adj_primary_gammas_per_event.

Referenced by G4AdjointSimManager::SetNbAdjointPrimaryGammasPerEvent().

◆ SetNbPrimaryFwdGammasPerEvent()

void G4AdjointPrimaryGeneratorAction::SetNbPrimaryFwdGammasPerEvent ( G4int nb )

inline

Definition at line 123 of file G4AdjointPrimaryGeneratorAction.hh.

    {
      nb_fwd_gammas_per_event = nb;
    }

References nb_fwd_gammas_per_event.

Referenced by G4AdjointSimManager::SetNbOfPrimaryFwdGammasPerEvent().

◆ SetPrimaryIon()

void G4AdjointPrimaryGeneratorAction::SetPrimaryIon	(	G4ParticleDefinition *	adjointIon,
		G4ParticleDefinition *	fwdIon
	)

Definition at line 336 of file G4AdjointPrimaryGeneratorAction.cc.

{
  fwd_ion = fwdIon;
  adj_ion = adjointIon;
  UpdateListOfPrimaryParticles();
}

References adj_ion, fwd_ion, and UpdateListOfPrimaryParticles().

Referenced by G4AdjointSimManager::SetPrimaryIon().

◆ SetRndmFlag()

void G4AdjointPrimaryGeneratorAction::SetRndmFlag ( const G4String & val )

inline

Definition at line 107 of file G4AdjointPrimaryGeneratorAction.hh.

    {
      rndmFlag = val;
    }

References rndmFlag.

◆ SetSphericalAdjointPrimarySource()

void G4AdjointPrimaryGeneratorAction::SetSphericalAdjointPrimarySource	(	G4double	radius,
		G4ThreeVector	pos
	)

Definition at line 248 of file G4AdjointPrimaryGeneratorAction.cc.

{
  radius_spherical_source = radius;
  center_spherical_source = center_pos;
  type_of_adjoint_source  = "Spherical";
  theAdjointPrimaryGenerator->SetSphericalAdjointPrimarySource(radius,
                                                               center_pos);
}

References center_spherical_source, radius_spherical_source, G4AdjointPrimaryGenerator::SetSphericalAdjointPrimarySource(), theAdjointPrimaryGenerator, and type_of_adjoint_source.

Referenced by G4AdjointSimManager::DefineSphericalAdjointSource(), and G4AdjointSimManager::DefineSphericalAdjointSourceWithCentreAtTheCentreOfAVolume().

◆ UpdateListOfPrimaryParticles()

void G4AdjointPrimaryGeneratorAction::UpdateListOfPrimaryParticles ( )

Definition at line 296 of file G4AdjointPrimaryGeneratorAction.cc.

{
  G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
  ListOfPrimaryFwdParticles.clear();
  ListOfPrimaryAdjParticles.clear();
  for(auto iter = PrimariesConsideredInAdjointSim.cbegin();
      iter != PrimariesConsideredInAdjointSim.cend(); ++iter)
  {
    if(iter->second)
    {
      G4String fwd_particle_name = iter->first;
      if(fwd_particle_name != "ion")
      {
        G4String adj_particle_name = G4String("adj_") + fwd_particle_name;
        ListOfPrimaryFwdParticles.push_back(
          theParticleTable->FindParticle(fwd_particle_name));
        ListOfPrimaryAdjParticles.push_back(
          theParticleTable->FindParticle(adj_particle_name));
      }
      else
      {
        if(fwd_ion)
        {
          ion_name              = fwd_ion->GetParticleName();
          G4String adj_ion_name = G4String("adj_") + ion_name;
          ListOfPrimaryFwdParticles.push_back(fwd_ion);
          ListOfPrimaryAdjParticles.push_back(adj_ion);
        }
        else
        {
          ListOfPrimaryFwdParticles.push_back(nullptr);
          ListOfPrimaryAdjParticles.push_back(nullptr);
        }
      }
    }
  }
}