#include <G4AdjointPrimaryGeneratorAction.hh>

Inheritance diagram for G4AdjointPrimaryGeneratorAction:

Collaboration diagram for G4AdjointPrimaryGeneratorAction:

Public Member Functions
	G4AdjointPrimaryGeneratorAction ()

	~G4AdjointPrimaryGeneratorAction ()

void	GeneratePrimaries (G4Event *)

void	SetRndmFlag (const G4String &val)

void	SetEmin (G4double val)

void	SetEmax (G4double val)

void	SetEminIon (G4double val)

void	SetEmaxIon (G4double val)

void	SetSphericalAdjointPrimarySource (G4double radius, G4ThreeVector pos)

void	SetAdjointPrimarySourceOnAnExtSurfaceOfAVolume (const G4String &volume_name)

void	ConsiderParticleAsPrimary (const G4String &particle_name)

void	NeglectParticleAsPrimary (const G4String &particle_name)

void	SetPrimaryIon (G4ParticleDefinition adjointIon, G4ParticleDefinition fwdIon)

void	UpdateListOfPrimaryParticles ()

size_t	GetNbOfAdjointPrimaryTypes ()

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

const G4String &	GetPrimaryIonName ()

void	SetNbPrimaryFwdGammasPerEvent (G4int nb)

Public Member Functions inherited from G4VUserPrimaryGeneratorAction
	G4VUserPrimaryGeneratorAction ()

virtual	~G4VUserPrimaryGeneratorAction ()

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

	G4AdjointPrimaryGeneratorAction (const G4AdjointPrimaryGeneratorAction &)

G4AdjointPrimaryGeneratorAction &	operator= (const G4AdjointPrimaryGeneratorAction &)

Private Attributes
G4String	rndmFlag

G4AdjointPrimaryGenerator *	theAdjointPrimaryGenerator

G4double	Emin

G4double	Emax

G4double	EminIon

G4double	EmaxIon

std::vector< G4ParticleDefinition * >	ListOfPrimaryFwdParticles

std::vector< G4ParticleDefinition * >	ListOfPrimaryAdjParticles

std::map< G4String, G4bool >	PrimariesConsideredInAdjointSim

size_t	index_particle

G4ThreeVector	pos

G4ThreeVector	direction

G4ThreeVector	p

G4String	type_of_adjoint_source

G4double	radius_spherical_source

G4ThreeVector	center_spherical_source

G4int	nb_fwd_gammas_per_event

G4ParticleDefinition *	fwd_ion

G4ParticleDefinition *	adj_ion

G4String	ion_name

Detailed Description

Definition at line 78 of file G4AdjointPrimaryGeneratorAction.hh.

Constructor & Destructor Documentation

◆ G4AdjointPrimaryGeneratorAction() [1/2]

G4AdjointPrimaryGeneratorAction::G4AdjointPrimaryGeneratorAction ( )

Definition at line 49 of file G4AdjointPrimaryGeneratorAction.cc.

   : Emin(0.), Emax(0.), EminIon(0.), EmaxIon(0.),
     index_particle(100000),
     radius_spherical_source(0.), fwd_ion(0), adj_ion(0), 
     ion_name("not_defined")
 {
   theAdjointPrimaryGenerator= new G4AdjointPrimaryGenerator();
 
   PrimariesConsideredInAdjointSim[G4String("e-")]=false;
   PrimariesConsideredInAdjointSim[G4String("gamma")]=false;
   PrimariesConsideredInAdjointSim[G4String("proton")]=false;
   PrimariesConsideredInAdjointSim[G4String("ion")]=false;
 
   ListOfPrimaryFwdParticles.clear();
   ListOfPrimaryAdjParticles.clear();
   nb_fwd_gammas_per_event = 10;
 }

◆ ~G4AdjointPrimaryGeneratorAction()

G4AdjointPrimaryGeneratorAction::~G4AdjointPrimaryGeneratorAction ( )

Definition at line 68 of file G4AdjointPrimaryGeneratorAction.cc.

 {
   delete theAdjointPrimaryGenerator;
 }

◆ G4AdjointPrimaryGeneratorAction() [2/2]

G4AdjointPrimaryGeneratorAction::G4AdjointPrimaryGeneratorAction ( const G4AdjointPrimaryGeneratorAction & )

private

Member Function Documentation

◆ ComputeEnergyDistWeight()

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

private

Definition at line 245 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();
  
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConsiderParticleAsPrimary()

void G4AdjointPrimaryGeneratorAction::ConsiderParticleAsPrimary ( const G4String & particle_name )

Definition at line 281 of file G4AdjointPrimaryGeneratorAction.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GeneratePrimaries()

void G4AdjointPrimaryGeneratorAction::GeneratePrimaries ( G4Event * anEvent )

virtual

Implements G4VUserPrimaryGeneratorAction.

Definition at line 74 of file G4AdjointPrimaryGeneratorAction.cc.

 {  G4int evt_id=anEvent->GetEventID();
    size_t n=ListOfPrimaryAdjParticles.size();
    index_particle=size_t(evt_id)-n*(size_t(evt_id)/n);
 
 
    G4double E1=Emin;
    G4double E2=Emax;
    if (!ListOfPrimaryAdjParticles[index_particle]) 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;
    }
    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();
 
    /*if (ListOfPrimaryAdjParticles[index_particle]->GetParticleName() == "adj_gamma"){
 
       theAdjointPrimaryGenerator
               ->ComputeAccumulatedDepthVectorAlongBackRay(pos,dir,ekin,ListOfPrimaryAdjParticles[index_particle]);
 
 
       G4double distance = theAdjointPrimaryGenerator
        ->SampleDistanceAlongBackRayAndComputeWeightCorrection(weight_correction);
 
       //pos=pos+dir*distance;
       //fwdPrimVertex->SetPosition(pos[0],pos[1],pos[2]);
    }
    */
    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 (int 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);
        }
    }
 
 
    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.;
    adjPrimVertex->SetWeight(adjoint_weight);
 
 
 
 
    G4AdjointSimManager::GetInstance()->SetAdjointTrackingMode(true);
 
 
 
   /* if ( !last_generated_part_was_adjoint ) {
      
      index_particle++;
      if (index_particle >= ListOfPrimaryAdjParticles.size()) index_particle =0;
      
     
      G4double E1=Emin;
      G4double E2=Emax;
      if (!ListOfPrimaryAdjParticles[index_particle]) 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;
      }
      theAdjointPrimaryGenerator->GenerateAdjointPrimaryVertex(anEvent,
                                   ListOfPrimaryAdjParticles[index_particle],
                                   E1,E2);
      G4PrimaryVertex* aPrimVertex = anEvent->GetPrimaryVertex();
   
   
       p=aPrimVertex->GetPrimary()->GetMomentum();
       pos=aPrimVertex->GetPosition();
       G4double pmag=p.mag();
       
       G4double m0=ListOfPrimaryAdjParticles[index_particle]->GetPDGMass();
       G4double ekin=std::sqrt( m0*m0 + pmag*pmag) -m0;
     
   
       //The factor pi is to normalise the weight to the directional flux
       G4double adjoint_source_area = G4AdjointSimManager::GetInstance()->GetAdjointSourceArea();
       G4double adjoint_weight = ComputeEnergyDistWeight(ekin,E1,E2)*adjoint_source_area*pi;
 
       aPrimVertex->SetWeight(adjoint_weight);
 
       last_generated_part_was_adjoint =true;
       G4AdjointSimManager::GetInstance()->SetAdjointTrackingMode(true);
       G4AdjointSimManager::GetInstance()->RegisterAdjointPrimaryWeight(adjoint_weight);
    }
    else {
           //fwd particle equivalent to the last generated adjoint particle ios generated    
       G4PrimaryVertex* aPrimVertex = new G4PrimaryVertex();
       aPrimVertex->SetPosition(pos.x(),pos.y(),pos.z());
       aPrimVertex->SetT0(0.);
       G4PrimaryParticle* aPrimParticle = new G4PrimaryParticle(ListOfPrimaryFwdParticles[index_particle],
                                -p.x(),-p.y(),-p.z()); 
     
       aPrimVertex->SetPrimary(aPrimParticle);
       anEvent->AddPrimaryVertex(aPrimVertex);                          
       last_generated_part_was_adjoint =false;
       G4AdjointSimManager::GetInstance()->SetAdjointTrackingMode(false);
     */
 
 }

Here is the call graph for this function:

◆ GetListOfPrimaryFwdParticles()

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

inline

Definition at line 100 of file G4AdjointPrimaryGeneratorAction.hh.

100 {

101 return &ListOfPrimaryFwdParticles;}

G4AdjointPrimaryGeneratorAction::ListOfPrimaryFwdParticles

std::vector< G4ParticleDefinition * > ListOfPrimaryFwdParticles

Definition: G4AdjointPrimaryGeneratorAction.hh:125

Here is the caller graph for this function:

◆ GetNbOfAdjointPrimaryTypes()

size_t G4AdjointPrimaryGeneratorAction::GetNbOfAdjointPrimaryTypes ( )

inline

Definition at line 99 of file G4AdjointPrimaryGeneratorAction.hh.

99 {return ListOfPrimaryAdjParticles.size();}

G4AdjointPrimaryGeneratorAction::ListOfPrimaryAdjParticles

std::vector< G4ParticleDefinition * > ListOfPrimaryAdjParticles

Definition: G4AdjointPrimaryGeneratorAction.hh:126

Here is the caller graph for this function:

◆ GetPrimaryIonName()

const G4String& G4AdjointPrimaryGeneratorAction::GetPrimaryIonName ( )

inline

Definition at line 102 of file G4AdjointPrimaryGeneratorAction.hh.

102 {return ion_name;}

G4AdjointPrimaryGeneratorAction::ion_name

G4String ion_name

Definition: G4AdjointPrimaryGeneratorAction.hh:143

Here is the caller graph for this function:

◆ NeglectParticleAsPrimary()

void G4AdjointPrimaryGeneratorAction::NeglectParticleAsPrimary ( const G4String & particle_name )

Definition at line 290 of file G4AdjointPrimaryGeneratorAction.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

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

private

◆ SetAdjointPrimarySourceOnAnExtSurfaceOfAVolume()

void G4AdjointPrimaryGeneratorAction::SetAdjointPrimarySourceOnAnExtSurfaceOfAVolume ( const G4String & volume_name )

Definition at line 274 of file G4AdjointPrimaryGeneratorAction.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetEmax()

void G4AdjointPrimaryGeneratorAction::SetEmax ( G4double val )

Definition at line 226 of file G4AdjointPrimaryGeneratorAction.cc.

 {
   Emax=val;
   EmaxIon=val;
 }

Here is the caller graph for this function:

◆ SetEmaxIon()

void G4AdjointPrimaryGeneratorAction::SetEmaxIon ( G4double val )

Definition at line 239 of file G4AdjointPrimaryGeneratorAction.cc.

 {
   EmaxIon=val;
 }

Here is the caller graph for this function:

◆ SetEmin()

void G4AdjointPrimaryGeneratorAction::SetEmin ( G4double val )

Definition at line 219 of file G4AdjointPrimaryGeneratorAction.cc.

 {
   Emin=val;
   EminIon=val;
 }

Here is the caller graph for this function:

◆ SetEminIon()

void G4AdjointPrimaryGeneratorAction::SetEminIon ( G4double val )

Definition at line 233 of file G4AdjointPrimaryGeneratorAction.cc.

 {
   EminIon=val;
 }

Here is the caller graph for this function:

◆ SetNbPrimaryFwdGammasPerEvent()

void G4AdjointPrimaryGeneratorAction::SetNbPrimaryFwdGammasPerEvent ( G4int nb )

inline

Definition at line 103 of file G4AdjointPrimaryGeneratorAction.hh.

103 {nb_fwd_gammas_per_event=nb;}

G4AdjointPrimaryGeneratorAction::nb_fwd_gammas_per_event

G4int nb_fwd_gammas_per_event

Definition: G4AdjointPrimaryGeneratorAction.hh:137

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetPrimaryIon()

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

Definition at line 337 of file G4AdjointPrimaryGeneratorAction.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetRndmFlag()

void G4AdjointPrimaryGeneratorAction::SetRndmFlag ( const G4String & val )

inline

Definition at line 88 of file G4AdjointPrimaryGeneratorAction.hh.

88 { rndmFlag = val;}

G4AdjointPrimaryGeneratorAction::rndmFlag

G4String rndmFlag

Definition: G4AdjointPrimaryGeneratorAction.hh:111

Here is the call graph for this function:

◆ SetSphericalAdjointPrimarySource()

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

Definition at line 265 of file G4AdjointPrimaryGeneratorAction.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateListOfPrimaryParticles()

void G4AdjointPrimaryGeneratorAction::UpdateListOfPrimaryParticles ( )

Definition at line 299 of file G4AdjointPrimaryGeneratorAction.cc.

 {
     G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
     ListOfPrimaryFwdParticles.clear();
     ListOfPrimaryAdjParticles.clear();
     std::map<G4String, G4bool>::iterator iter;
     for( iter = PrimariesConsideredInAdjointSim.begin(); iter != PrimariesConsideredInAdjointSim.end(); ++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));
             if ( fwd_particle_name == "gamma") {
                 for (G4int i=0;i<2;i++){
                     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(0);
                 ListOfPrimaryAdjParticles.push_back(0);
                 
             }   
         }
     }   
    }
 }