#include <XrayFluoPlanePrimaryGeneratorAction.hh>

Inheritance diagram for XrayFluoPlanePrimaryGeneratorAction:

Collaboration diagram for XrayFluoPlanePrimaryGeneratorAction:

Public Member Functions
	XrayFluoPlanePrimaryGeneratorAction (const XrayFluoPlaneDetectorConstruction *)

	~XrayFluoPlanePrimaryGeneratorAction ()

void	GeneratePrimaries (G4Event *)

void	SetRndmFlag (G4String val)

void	SetRndmVert (G4String val)

void	SetSpectrum (G4String val)

void	SetIsoVert (G4String val)

Public Member Functions inherited from G4VUserPrimaryGeneratorAction
	G4VUserPrimaryGeneratorAction ()

virtual	~G4VUserPrimaryGeneratorAction ()

Private Attributes
G4ParticleGun *	particleGun

const XrayFluoPlaneDetectorConstruction *	XrayFluoDetector

XrayFluoPlanePrimaryGeneratorMessenger *	gunMessenger

XrayFluoRunAction *	runManager

G4String	rndmFlag

G4String	beam

G4String	spectrum

G4String	isoVert

Detailed Description

Definition at line 53 of file XrayFluoPlanePrimaryGeneratorAction.hh.

Constructor & Destructor Documentation

◆ XrayFluoPlanePrimaryGeneratorAction()

XrayFluoPlanePrimaryGeneratorAction::XrayFluoPlanePrimaryGeneratorAction ( const XrayFluoPlaneDetectorConstruction * XrayFluoDC )

Definition at line 56 of file XrayFluoPlanePrimaryGeneratorAction.cc.

   :rndmFlag("on"),beam("off"),spectrum("off"),isoVert("off")
 {
 
   XrayFluoDetector = XrayFluoDC;
 
   G4int n_particle = 1;
   particleGun  = new G4ParticleGun(n_particle);
   
   //create a messenger for this class
   gunMessenger = new XrayFluoPlanePrimaryGeneratorMessenger(this);
   runManager = new XrayFluoRunAction();
   
   // default particle kinematic
   
   G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
   G4String particleName;
   G4ParticleDefinition* particle
     = particleTable->FindParticle(particleName="gamma");
   particleGun->SetParticleDefinition(particle);
   particleGun->SetParticleMomentumDirection(G4ThreeVector(0.,0.,1.));
   
 
   particleGun->SetParticleEnergy(10.*keV);
   G4double position = -0.5*(XrayFluoDetector->GetWorldSizeZ());
   particleGun->SetParticlePosition(G4ThreeVector(0.*cm,0.*cm,position));
 
   G4cout << "XrayFluoPlanePrimaryGeneratorAction created  UUUUUUUUUUAAAAAAAAAAAAAAAAAAAAAAAaa" << G4endl;
   
 }

Here is the call graph for this function:

◆ ~XrayFluoPlanePrimaryGeneratorAction()

XrayFluoPlanePrimaryGeneratorAction::~XrayFluoPlanePrimaryGeneratorAction ( )

Definition at line 90 of file XrayFluoPlanePrimaryGeneratorAction.cc.

 {
   delete particleGun;
   delete gunMessenger;
   delete runManager;
 
   G4cout << "XrayFluoPlanePrimaryGeneratorAction deleted" << G4endl;
 
 }

Member Function Documentation

◆ GeneratePrimaries()

void XrayFluoPlanePrimaryGeneratorAction::GeneratePrimaries ( G4Event * anEvent )

virtual

Implements G4VUserPrimaryGeneratorAction.

Definition at line 102 of file XrayFluoPlanePrimaryGeneratorAction.cc.

 {
   //this function is called at the begining of event
   // 
   G4double z0 = -0.5*(XrayFluoDetector->GetWorldSizeZ());
   G4double y0 = 0.*m, x0 = 0.*m;
   G4double dX = 0.5*(XrayFluoDetector->GetWorldSizeXY())-(XrayFluoDetector->GetPlaneSizeXY());
   if (rndmFlag == "on")
 
     {y0 = (XrayFluoDetector->GetPlaneSizeXY())*(G4UniformRand()-0.5); 
     x0 = (XrayFluoDetector->GetPlaneSizeXY())*(G4UniformRand()-0.5) + dX; 
     } 
 
   z0 = -1 * dX;
 
   particleGun->SetParticleMomentumDirection(G4ThreeVector(-1.,0.,1.));
 
   particleGun->SetParticlePosition(G4ThreeVector(x0,y0,z0));
   
   //randomize starting point
   if (beam == "on")
     {
       G4double radius = 0.5 * mm;
       G4double rho = radius*std::sqrt(G4UniformRand());
       G4double theta = 2*pi*G4UniformRand()*rad;
       G4double position = -0.5*(XrayFluoDetector->GetWorldSizeZ());
       
       G4double y = rho * std::sin(theta);
       G4double x = rho * std::cos(theta);
       
       particleGun->SetParticlePosition(G4ThreeVector(x,y,position));
     }
   //shoot particles according to a certain spectrum
   if (spectrum =="on")
     {
       G4String particle =  particleGun->GetParticleDefinition()
     ->GetParticleName();
       if(particle == "proton"|| particle == "alpha")
     {
       G4DataVector* energies =  runManager->GetEnergies();
       G4DataVector* data =  runManager->GetData();
      
       G4double sum = runManager->GetDataSum();
       G4double partSum = 0;
       G4int j = 0;
       G4double random= sum*G4UniformRand();
       while (partSum<random)
         {
           partSum += (*data)[j];
           j++;
         }
      
       particleGun->SetParticleEnergy((*energies)[j]);
     
     }
       else if (particle == "gamma")
     {
       const XrayFluoDataSet* dataSet = runManager->GetGammaSet();
       
       G4int i = 0;
       G4int id = 0;
       G4double minEnergy = 0. * keV;
       G4double particleEnergy= 0.;
       G4double maxEnergy = 10. * keV;
       G4double energyRange = maxEnergy - minEnergy;
 
        while ( i == 0)
         {
           G4double random = G4UniformRand();
           
           G4double randomNum = G4UniformRand(); //*5.0E6;
           
           particleEnergy = (random*energyRange) + minEnergy;
           
           if ((dataSet->FindValue(particleEnergy,id)) > randomNum)
         {
           i = 1;
           
         }
         }
        particleGun->SetParticleEnergy(particleEnergy);
     }
     }
   
   if (isoVert == "on")
     {
       G4double rho = 1. *m;
       //theta in [0;pi/2]
       G4double theta = (pi/2)*G4UniformRand();
       //phi in [-pi;pi]
       G4double phi = (G4UniformRand()*2*pi)- pi;
       G4double x = rho*std::sin(theta)*std::sin(phi);
       G4double y = rho*std::sin(theta)*std::cos(phi);
       G4double z = -(rho*std::cos(theta));
       particleGun->SetParticlePosition(G4ThreeVector(x,y,z));
       
       G4double Xdim = XrayFluoDetector->GetPlaneSizeXY();
       G4double Ydim = XrayFluoDetector->GetPlaneSizeXY();
       
       G4double Dx = Xdim*(G4UniformRand()-0.5);
       
       G4double Dy = Ydim*(G4UniformRand()-0.5);
       
       particleGun->SetParticleMomentumDirection(G4ThreeVector(-x+Dx,-y+Dy,-z));
       
     }
 #ifdef G4ANALYSIS_USE 
 
   G4double partEnergy = particleGun->GetParticleEnergy();
   XrayFluoAnalysisManager* analysis =  XrayFluoAnalysisManager::getInstance();
   analysis->analysePrimaryGenerator(partEnergy/keV);
 
 #endif
  
   particleGun->GeneratePrimaryVertex(anEvent);
 }