#include <Doxymodules_hadronic.h>

Inheritance diagram for FFPrimaryGeneratorAction:

Public Member Functions
	FFPrimaryGeneratorAction ()

virtual void	GeneratePrimaries (G4Event *event)

virtual	~FFPrimaryGeneratorAction ()

Private Member Functions
G4ThreeVector	GetNeutronSourceCenter (void)

Private Attributes
G4long	fEventNumber

G4VPhysicalVolume *	fH2OPhysical

G4VPhysicalVolume *	fNeutronPhysical

G4Tubs *	fNeutronSolid

G4ParticleGun *const	fParticleGun

G4VPhysicalVolume *	fTankPhysical

Detailed Description

Definition at line 119 of file Doxymodules_hadronic.h.

Constructor & Destructor Documentation

◆ FFPrimaryGeneratorAction()

FFPrimaryGeneratorAction::FFPrimaryGeneratorAction ( )

Definition at line 66 of file FFPrimaryGeneratorAction.cc.

:   G4VUserPrimaryGeneratorAction(),
#ifndef NDEBUG
    fEventNumber(0),
#endif // NDEBUG
    fH2OPhysical(NULL),
    fNeutronPhysical(NULL),
    fNeutronSolid(NULL),
    fParticleGun(new G4ParticleGun(1)),
    fTankPhysical(NULL)
{
    fParticleGun->SetParticleDefinition(G4Neutron::Definition());
    fParticleGun->SetParticleEnergy(4.5 * MeV);
}

◆ ~FFPrimaryGeneratorAction()

FFPrimaryGeneratorAction::~FFPrimaryGeneratorAction ( )

virtual

Definition at line 198 of file FFPrimaryGeneratorAction.cc.

{
    delete fParticleGun;
}

Member Function Documentation

◆ GeneratePrimaries()

void FFPrimaryGeneratorAction::GeneratePrimaries ( G4Event * event )

virtual

Definition at line 83 of file FFPrimaryGeneratorAction.cc.

{
#ifndef NDEBUG
    G4cout << "Shooting event " << ++fEventNumber << G4endl;
#endif // NDEBUG
    const G4ThreeVector sourceCenter = GetNeutronSourceCenter();
    
    // Sample the neutron source location
    const G4double radius = fNeutronSolid->GetOuterRadius();
    const G4double z = fNeutronSolid->GetZHalfLength() * 2;
    G4ThreeVector randomLocation;
    randomLocation.setRThetaPhi(radius * std::sqrt(G4UniformRand()),
                                G4UniformRand() * 180 * deg,
                                0);
    randomLocation.setZ(z * (G4UniformRand() - 0.5));
    G4ThreeVector location(randomLocation.x() + sourceCenter.x(),
                           randomLocation.y() + sourceCenter.y(),
                           randomLocation.z() + sourceCenter.z());
#ifndef NDEBUG
    G4cout << "Emission Location: r: " << location << G4endl;
#endif // NDEBUG
    
    // Sample the neutron emission direction
    G4ThreeVector direction;
    direction.setRThetaPhi(1.0,
                           std::acos(G4UniformRand() * 2 - 1),
                           (G4UniformRand() * 2 - 1) * 180 * deg);
#ifndef NDEBUG
    G4cout << "Emission Direction: r: " << direction << G4endl;
#endif // NDEBUG
    
    // Load the event
    fParticleGun->SetParticlePosition(location);
    fParticleGun->SetParticleMomentumDirection(direction);
    fParticleGun->GeneratePrimaryVertex(event);
}

◆ GetNeutronSourceCenter()

G4ThreeVector FFPrimaryGeneratorAction::GetNeutronSourceCenter ( void )

private

Definition at line 122 of file FFPrimaryGeneratorAction.cc.

{
    // Get the dimensions of the neutron source
    if(fNeutronSolid == NULL)
    {
        G4LogicalVolume* temp
            = G4LogicalVolumeStore::GetInstance()->GetVolume("NeutronSource");
        if(temp != NULL)
        {
            fNeutronSolid = dynamic_cast< G4Tubs* >(temp->GetSolid());
        }
        
        if(fNeutronSolid == NULL)
        {
            G4Exception("FFPrimaryGeneratorAction::"
                            "GeneratePrimaries(G4Event*)",
                        "Neutron source solid volume not found",
                        EventMustBeAborted,
                        "This run will be aborted");
        }
    }
    
    // Get the position of the neutron source within the water
    if(fNeutronPhysical == NULL)
    {
        fNeutronPhysical = G4PhysicalVolumeStore::GetInstance()
            ->GetVolume("NeutronSource");
    }
    
    if(fNeutronPhysical == NULL)
    {
        G4Exception("FFPrimaryGeneratorAction::GetNeutronSourceCenter(void)",
                    "Neutron source physical volume not found",
                    EventMustBeAborted,
                    "This run will be aborted");
    }
    
    // Get the position of the water within the tank
    if(fH2OPhysical == NULL)
    {
        fH2OPhysical = G4PhysicalVolumeStore::GetInstance()
            ->GetVolume("Tank_H2O");
    
        if(fH2OPhysical == NULL)
        {
            G4Exception("FFPrimaryGeneratorAction::"
                            "GetNeutronSourceCenter(void)",
                        "Tank H2O physical volume not found",
                        EventMustBeAborted,
                        "This run will be aborted");
        }
    }
    
    // Get the position of the tank within the world
    if(fTankPhysical == NULL)
    {
        fTankPhysical = G4PhysicalVolumeStore::GetInstance()
            ->GetVolume("Tank_Wall");
    
        if(fTankPhysical == NULL)
        {
            G4Exception("FFPrimaryGeneratorAction::"
                            "GetNeutronSourceCenter(void)",
                        "Tank physical volume not found",
                        EventMustBeAborted,
                        "This run will be aborted");
        }
    }
    
    return fNeutronPhysical->GetTranslation()
               + fH2OPhysical->GetTranslation()
               + fTankPhysical->GetTranslation();
}