G4AntiNeutronAnnihilationAtRest Class Reference

#include <G4AntiNeutronAnnihilationAtRest.hh>

Inheritance diagram for G4AntiNeutronAnnihilationAtRest:

Collaboration diagram for G4AntiNeutronAnnihilationAtRest:

Public Member Functions
	G4AntiNeutronAnnihilationAtRest (const G4String &processName="AntiNeutronAnnihilationAtRest", G4ProcessType aType=fHadronic)
	~G4AntiNeutronAnnihilationAtRest ()
G4bool	IsApplicable (const G4ParticleDefinition &)
void	PreparePhysicsTable (const G4ParticleDefinition &)
void	BuildPhysicsTable (const G4ParticleDefinition &)
G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
G4double	GetMeanLifeTime (const G4Track &, G4ForceCondition *)
G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
G4int	GetNumberOfSecondaries ()
G4GHEKinematicsVector *	GetSecondaryKinematics ()
Public Member Functions inherited from G4VRestProcess
	G4VRestProcess (const G4String &, G4ProcessType aType=fNotDefined)
	G4VRestProcess (G4VRestProcess &)
virtual	~G4VRestProcess ()
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &, G4double, G4ForceCondition *)
virtual G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &)
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)
Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
	G4VProcess (const G4VProcess &right)
virtual	~G4VProcess ()
G4int	operator== (const G4VProcess &right) const
G4int	operator!= (const G4VProcess &right) const
G4double	GetCurrentInteractionLength () const
void	SetPILfactor (G4double value)
G4double	GetPILfactor () const
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
const G4String &	GetProcessName () const
G4ProcessType	GetProcessType () const
void	SetProcessType (G4ProcessType)
G4int	GetProcessSubType () const
void	SetProcessSubType (G4int)
virtual void	StartTracking (G4Track *)
virtual void	EndTracking ()
virtual void	SetProcessManager (const G4ProcessManager *)
virtual const G4ProcessManager *	GetProcessManager ()
virtual void	ResetNumberOfInteractionLengthLeft ()
G4double	GetNumberOfInteractionLengthLeft () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4bool	isAtRestDoItIsEnabled () const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
virtual void	DumpInfo () const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
virtual void	SetMasterProcess (G4VProcess *masterP)
const G4VProcess *	GetMasterProcess () const
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Private Member Functions
G4AntiNeutronAnnihilationAtRest &	operator= (const G4AntiNeutronAnnihilationAtRest &right)
	G4AntiNeutronAnnihilationAtRest (const G4AntiNeutronAnnihilationAtRest &)
void	GenerateSecondaries ()
void	Poisso (G4float, G4int *)
void	Normal (G4float *)
void	AntiNeutronAnnihilation (G4int *)
G4double	ExNu (G4float)
G4int	NFac (G4int)

Private Attributes
G4float	globalTime
G4float	targetAtomicMass
G4float	targetCharge
G4GHEKinematicsVector *	pv
G4GHEKinematicsVector *	eve
G4GHEKinematicsVector *	gkin
G4float	evapEnergy1
G4float	evapEnergy3
G4int	ngkine
G4int	ntot
G4GHEKinematicsVector	result
G4float	massPionMinus
G4float	massPionZero
G4float	massPionPlus
G4float	massGamma
G4float	massAntiNeutron
G4float	massNeutron
G4ParticleDefinition *	pdefGamma
G4ParticleDefinition *	pdefPionPlus
G4ParticleDefinition *	pdefPionZero
G4ParticleDefinition *	pdefPionMinus
G4ParticleDefinition *	pdefProton
G4ParticleDefinition *	pdefNeutron
G4ParticleDefinition *	pdefAntiNeutron
G4ParticleDefinition *	pdefDeuteron
G4ParticleDefinition *	pdefTriton
G4ParticleDefinition *	pdefAlpha

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)
void	ClearNumberOfInteractionLengthLeft ()
Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager
G4VParticleChange *	pParticleChange
G4ParticleChange	aParticleChange
G4double	theNumberOfInteractionLengthLeft
G4double	currentInteractionLength
G4double	theInitialNumberOfInteractionLength
G4String	theProcessName
G4String	thePhysicsTableFileName
G4ProcessType	theProcessType
G4int	theProcessSubType
G4double	thePILfactor
G4bool	enableAtRestDoIt
G4bool	enableAlongStepDoIt
G4bool	enablePostStepDoIt
G4int	verboseLevel

Detailed Description

Definition at line 47 of file G4AntiNeutronAnnihilationAtRest.hh.

Constructor & Destructor Documentation

G4AntiNeutronAnnihilationAtRest() [1/2]

G4AntiNeutronAnnihilationAtRest::G4AntiNeutronAnnihilationAtRest ( const G4AntiNeutronAnnihilationAtRest &  )

private

G4AntiNeutronAnnihilationAtRest() [2/2]

G4AntiNeutronAnnihilationAtRest::G4AntiNeutronAnnihilationAtRest	(	const G4String &	processName = "AntiNeutronAnnihilationAtRest",
		G4ProcessType	aType = fHadronic
	)

Definition at line 46 of file G4AntiNeutronAnnihilationAtRest.cc.

                                                                                      :
  G4VRestProcess (processName, aType),       // initialization
  massPionMinus(G4PionMinus::PionMinus()->GetPDGMass()/GeV),
  massPionZero(G4PionZero::PionZero()->GetPDGMass()/GeV),
  massPionPlus(G4PionPlus::PionPlus()->GetPDGMass()/GeV),
  massGamma(G4Gamma::Gamma()->GetPDGMass()/GeV),
  massAntiNeutron(G4AntiNeutron::AntiNeutron()->GetPDGMass()/GeV),
  massNeutron(G4Neutron::Neutron()->GetPDGMass()/GeV),
  pdefGamma(G4Gamma::Gamma()),
  pdefPionPlus(G4PionPlus::PionPlus()),
  pdefPionZero(G4PionZero::PionZero()),
  pdefPionMinus(G4PionMinus::PionMinus()),
  pdefProton(G4Proton::Proton()),
  pdefNeutron(G4Neutron::Neutron()),
  pdefAntiNeutron(G4AntiNeutron::AntiNeutron()),
  pdefDeuteron(G4Deuteron::Deuteron()),
  pdefTriton(G4Triton::Triton()),
  pdefAlpha(G4Alpha::Alpha())
{
  G4HadronicDeprecate("G4AntiNeutronAnnihilationAtRest");
  if (verboseLevel>0) {
    G4cout << GetProcessName() << " is created "<< G4endl;
  }
  SetProcessSubType(fHadronAtRest);
  pv   = new G4GHEKinematicsVector [MAX_SECONDARIES+1];
  eve  = new G4GHEKinematicsVector [MAX_SECONDARIES];
  gkin = new G4GHEKinematicsVector [MAX_SECONDARIES];

  G4HadronicProcessStore::Instance()->RegisterExtraProcess(this);
  globalTime = targetAtomicMass = targetCharge = evapEnergy1 
    = evapEnergy3 = 0.0;
  ngkine = ntot = 0;
}

Here is the call graph for this function:

~G4AntiNeutronAnnihilationAtRest()

G4AntiNeutronAnnihilationAtRest::~G4AntiNeutronAnnihilationAtRest

(

)

Definition at line 83 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  G4HadronicProcessStore::Instance()->DeRegisterExtraProcess(this);
  delete [] pv;
  delete [] eve;
  delete [] gkin;
}

Here is the call graph for this function:

Member Function Documentation

AntiNeutronAnnihilation()

void G4AntiNeutronAnnihilationAtRest::AntiNeutronAnnihilation ( G4int *  nopt )

private

Definition at line 421 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  static G4ThreadLocal G4float brr[3] = { G4float(.125),G4float(.25),G4float(.5) };

  G4float r__1;

  static G4ThreadLocal G4int i, ii, kk;
  static G4ThreadLocal G4int nt;
  static G4ThreadLocal G4float cfa, eka;
  static G4ThreadLocal G4int ika, nbl;
  static G4ThreadLocal G4float ran, pcm;
  static G4ThreadLocal G4int isw;
  static G4ThreadLocal G4float tex;
  static G4ThreadLocal G4ParticleDefinition* ipa1;
  static G4ThreadLocal G4float ran1, ran2, ekin, tkin;
  static G4ThreadLocal G4float targ;
  static G4ThreadLocal G4ParticleDefinition* inve;
  static G4ThreadLocal G4float ekin1, ekin2, black;
  static G4ThreadLocal G4float pnrat, rmnve1, rmnve2;
  static G4ThreadLocal G4float ek, en;

  // *** ANTI NEUTRON ANNIHILATION AT REST ***
  // *** NVE 04-MAR-1988 CERN GENEVA ***
  // ORIGIN : H.FESEFELDT (09-JULY-1987)

  // NOPT=0    NO ANNIHILATION
  // NOPT=1    ANNIH.IN PI+ PI-
  // NOPT=2    ANNIH.IN PI0 PI0
  // NOPT=3    ANNIH.IN PI+ PI0
  // NOPT=4    ANNIH.IN GAMMA GAMMA

  pv[1].SetZero();
  pv[1].SetMass( massAntiNeutron );
  pv[1].SetKineticEnergyAndUpdate( 0. );
  pv[1].SetTOF( result.GetTOF() );
  pv[1].SetParticleDef( result.GetParticleDef() );
  isw = 1;
  ran = G4UniformRand();
  if (ran > brr[0]) {
    isw = 2;
  }
  if (ran > brr[1]) {
    isw = 3;
  }
  if (ran > brr[2]) {
    isw = 4;
  }
  *nopt = isw;
  // **
  // **  EVAPORATION
  // **
  rmnve1 = massPionPlus;
  rmnve2 = massPionMinus;
  if (isw == 2) {
    rmnve1 = massPionZero;
  }
  if (isw == 2) {
    rmnve2 = massPionZero;
  }
  if (isw == 3) {
    rmnve2 = massPionZero;
  }
  if (isw == 4) {
    rmnve1 = massGamma;
  }
  if (isw == 4) {
    rmnve2 = massGamma;
  }
  ek = massNeutron + massAntiNeutron - rmnve1 - rmnve2;
  tkin = ExNu(ek);
  ek -= tkin;
  if (ek < G4float(1e-4)) {
    ek = G4float(1e-4);
  }
  ek /= G4float(2.);
  en = ek + (rmnve1 + rmnve2) / G4float(2.);
  r__1 = en * en - rmnve1 * rmnve2;
  pcm = r__1 > 0 ? std::sqrt(r__1) : 0;
  pv[2].SetZero();
  pv[2].SetMass( rmnve1 );
  pv[3].SetZero();
  pv[3].SetMass( rmnve2 );
  if (isw > 3) {
    pv[2].SetMass( 0. );
    pv[3].SetMass( 0. );
  }
  pv[2].SetEnergyAndUpdate( std::sqrt(pv[2].GetMass()*pv[2].GetMass()+pcm*pcm) );
  pv[2].SetTOF( result.GetTOF() );
  pv[3].SetEnergy( std::sqrt(pv[3].GetMass()*pv[3].GetMass()+pcm*pcm) );
  pv[3].SetMomentumAndUpdate( -pv[2].GetMomentum().x(), -pv[2].GetMomentum().y(), -pv[2].GetMomentum().z() );
  pv[3].SetTOF( result.GetTOF() );
  switch ((int)isw) {
    case 1:
      pv[2].SetParticleDef( pdefPionPlus );
      pv[3].SetParticleDef( pdefPionMinus );
      break;
    case 2:
      pv[2].SetParticleDef( pdefPionZero );
      pv[3].SetParticleDef( pdefPionZero );
      break;
    case 3:
      pv[2].SetParticleDef( pdefPionPlus );
      pv[3].SetParticleDef( pdefPionZero );
      break;
    case 4:
      pv[2].SetParticleDef( pdefGamma );
      pv[3].SetParticleDef( pdefGamma );
      break;
    default:
      break;
  }
  nt = 3;
  if (targetAtomicMass >= G4float(1.5)) {
    cfa = (targetAtomicMass - G4float(1.)) / G4float(120.) *
      G4float(.025) * G4Exp(-G4double(targetAtomicMass - G4float(1.)) /
              G4float(120.));
    targ = G4float(1.);
    tex = evapEnergy1;
    if (tex >= G4float(.001)) {
      black = (targ * G4float(1.25) +
           G4float(1.5)) * evapEnergy1 / (evapEnergy1 + evapEnergy3);
      Poisso(black, &nbl);
      if (G4float(G4int(targ) + nbl) > targetAtomicMass) {
    nbl = G4int(targetAtomicMass - targ);
      }
      if (nt + nbl > (MAX_SECONDARIES - 2)) {
    nbl = (MAX_SECONDARIES - 2) - nt;
      }
      if (nbl > 0) {
    ekin = tex / nbl;
    ekin2 = G4float(0.);
    for (i = 1; i <= nbl; ++i) {
      if (nt == (MAX_SECONDARIES - 2)) {
        continue;
      }
      if (ekin2 > tex) {
        break;
      }
      ran1 = G4UniformRand();
      Normal(&ran2);
      ekin1 = -G4double(ekin) * G4Log(ran1) -
        cfa * (ran2 * G4float(.5) + G4float(1.));
      if (ekin1 < G4float(0.)) {
        ekin1 = G4Log(ran1) * G4float(-.01);
      }
      ekin1 *= G4float(1.);
      ekin2 += ekin1;
      if (ekin2 > tex) {
        ekin1 = tex - (ekin2 - ekin1);
      }
      if (ekin1 < G4float(0.)) {
        ekin1 = G4float(.001);
      }
      ipa1 = pdefNeutron;
      pnrat = G4float(1.) - targetCharge / targetAtomicMass;
      if (G4UniformRand() > pnrat) {
        ipa1 = pdefProton;
      }
      ++nt;
      pv[nt].SetZero();
      pv[nt].SetMass( ipa1->GetPDGMass()/GeV );
      pv[nt].SetKineticEnergyAndUpdate( ekin1 );
      pv[nt].SetTOF( result.GetTOF() );
      pv[nt].SetParticleDef( ipa1 );
    }
    if (targetAtomicMass >= G4float(230.) && ek <= G4float(2.)) {
      ii = nt + 1;
      kk = 0;
      eka = ek;
      if (eka > G4float(1.)) {
        eka *= eka;
      }
      if (eka < G4float(.1)) {
        eka = G4float(.1);
      }
      ika = G4int(G4float(3.6) / eka);
      for (i = 1; i <= nt; ++i) {
        --ii;
        if (pv[ii].GetParticleDef() != pdefProton) {
          continue;
        }
        ipa1 = pdefNeutron;
        pv[ii].SetMass( ipa1->GetPDGMass()/GeV );
        pv[ii].SetParticleDef( ipa1 );
        ++kk;
        if (kk > ika) {
          break;
        }
      }
    }
      }
    }
    // **
    // ** THEN ALSO DEUTERONS, TRITONS AND ALPHAS
    // **
    tex = evapEnergy3;
    if (tex >= G4float(.001)) {
      black = (targ * G4float(1.25) + G4float(1.5)) * evapEnergy3 /
    (evapEnergy1 + evapEnergy3);
      Poisso(black, &nbl);
      if (nt + nbl > (MAX_SECONDARIES - 2)) {
    nbl = (MAX_SECONDARIES - 2) - nt;
      }
      if (nbl > 0) {
    ekin = tex / nbl;
    ekin2 = G4float(0.);
    for (i = 1; i <= nbl; ++i) {
      if (nt == (MAX_SECONDARIES - 2)) {
        continue;
      }
      if (ekin2 > tex) {
        break;
      }
      ran1 = G4UniformRand();
      Normal(&ran2);
      ekin1 = -G4double(ekin) * G4Log(ran1) -
        cfa * (ran2 * G4float(.5) + G4float(1.));
      if (ekin1 < G4float(0.)) {
        ekin1 = G4Log(ran1) * G4float(-.01);
      }
      ekin1 *= G4float(1.);
      ekin2 += ekin1;
      if (ekin2 > tex) {
        ekin1 = tex - (ekin2 - ekin1);
      }
      if (ekin1 < G4float(0.)) {
        ekin1 = G4float(.001);
      }
      ran = G4UniformRand();
      inve = pdefDeuteron;
      if (ran > G4float(.6)) {
        inve = pdefTriton;
      }
      if (ran > G4float(.9)) {
        inve = pdefAlpha;
      }
      ++nt;
      pv[nt].SetZero();
      pv[nt].SetMass( inve->GetPDGMass()/GeV );
      pv[nt].SetKineticEnergyAndUpdate( ekin1 );
      pv[nt].SetTOF( result.GetTOF() );
      pv[nt].SetParticleDef( inve );
    }
      }
    }
  }
  result = pv[2];
  if (nt == 2) {
    return;
  }
  for (i = 3; i <= nt; ++i) {
    if (ntot >= MAX_SECONDARIES) {
      return;
    }
    eve[ntot++] = pv[i];
  }

} // AntiNeutronAnnihilation

Here is the call graph for this function:

Here is the caller graph for this function:

AtRestDoIt()

G4VParticleChange * G4AntiNeutronAnnihilationAtRest::AtRestDoIt ( const G4Track &  track, const G4Step &    )

virtual

Reimplemented from G4VRestProcess.

Definition at line 151 of file G4AntiNeutronAnnihilationAtRest.cc.

{

//   Initialize ParticleChange
//     all members of G4VParticleChange are set to equal to 
//     corresponding member in G4Track

  aParticleChange.Initialize(track);

//   Store some global quantities that depend on current material and particle

  globalTime = track.GetGlobalTime()/s;
  G4Material * aMaterial = track.GetMaterial();
  const G4int numberOfElements = aMaterial->GetNumberOfElements();
  const G4ElementVector* theElementVector = aMaterial->GetElementVector();

  const G4double* theAtomicNumberDensity = aMaterial->GetAtomicNumDensityVector();
  G4double normalization = 0;
  for ( G4int i1=0; i1 < numberOfElements; i1++ )
  {
    normalization += theAtomicNumberDensity[i1] ; // change when nucleon specific
                                                  // probabilities are included.
  }
  G4double runningSum= 0.;
  G4double random = G4UniformRand()*normalization;
  for ( G4int i2=0; i2 < numberOfElements; i2++ )
  {
    runningSum += theAtomicNumberDensity[i2]; // change when nucleon specific
                                              // probabilities are included.
    if (random<=runningSum)
    {
      targetCharge = G4double( ((*theElementVector)[i2])->GetZ());
      targetAtomicMass = (*theElementVector)[i2]->GetN();
    }
  }
  if (random>runningSum)
  {
    targetCharge = G4double( ((*theElementVector)[numberOfElements-1])->GetZ());
    targetAtomicMass = (*theElementVector)[numberOfElements-1]->GetN();
  }

  if (verboseLevel>1) {
    G4cout << "G4AntiNeutronAnnihilationAtRest::AtRestDoIt is invoked " <<G4endl;
    }

  G4ParticleMomentum momentum;
  G4float localtime;

  G4ThreeVector   position = track.GetPosition();

  GenerateSecondaries(); // Generate secondaries

  aParticleChange.SetNumberOfSecondaries( ngkine ); 

  for ( G4int isec = 0; isec < ngkine; isec++ ) {
    G4DynamicParticle* aNewParticle = new G4DynamicParticle;
    aNewParticle->SetDefinition( gkin[isec].GetParticleDef() );
    aNewParticle->SetMomentum( gkin[isec].GetMomentum() * GeV );

    localtime = globalTime + gkin[isec].GetTOF();

    G4Track* aNewTrack = new G4Track( aNewParticle, localtime*s, position );
        aNewTrack->SetTouchableHandle(track.GetTouchableHandle());
    aParticleChange.AddSecondary( aNewTrack ); 

  }

  aParticleChange.ProposeLocalEnergyDeposit( 0.0*GeV );

  aParticleChange.ProposeTrackStatus(fStopAndKill); // Kill the incident AntiNeutron

//   clear InteractionLengthLeft

  ResetNumberOfInteractionLengthLeft();

  return &aParticleChange;

}

Here is the call graph for this function:

Here is the caller graph for this function:

AtRestGetPhysicalInteractionLength()

G4double G4AntiNeutronAnnihilationAtRest::AtRestGetPhysicalInteractionLength ( const G4Track &  track, G4ForceCondition *  condition  )

virtual

Reimplemented from G4VRestProcess.

Definition at line 125 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  // beggining of tracking 
  ResetNumberOfInteractionLengthLeft();

  // condition is set to "Not Forced"
  *condition = NotForced;

  // get mean life time
  currentInteractionLength = GetMeanLifeTime(track, condition);

  if ((currentInteractionLength <0.0) || (verboseLevel>2)){
    G4cout << "G4AntiNeutronAnnihilationAtRestProcess::AtRestGetPhysicalInteractionLength ";
    G4cout << "[ " << GetProcessName() << "]" <<G4endl;
    track.GetDynamicParticle()->DumpInfo();
    G4cout << " in Material  " << track.GetMaterial()->GetName() <<G4endl;
    G4cout << "MeanLifeTime = " << currentInteractionLength/ns << "[ns]" <<G4endl;
  }

  return theNumberOfInteractionLengthLeft * currentInteractionLength;

}

Here is the call graph for this function:

BuildPhysicsTable()

void G4AntiNeutronAnnihilationAtRest::BuildPhysicsTable ( const G4ParticleDefinition &  p )

virtual

Reimplemented from G4VProcess.

Definition at line 96 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  G4HadronicProcessStore::Instance()->PrintInfo(&p);
}

Here is the call graph for this function:

ExNu()

G4double G4AntiNeutronAnnihilationAtRest::ExNu ( G4float  ek1 )

private

Definition at line 681 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  G4float ret_val, r__1;

  static G4ThreadLocal G4float cfa, gfa, ran1, ran2, ekin1, atno3;
  static G4ThreadLocal G4int magic;
  static G4ThreadLocal G4float fpdiv;

  // *** NUCLEAR EVAPORATION AS FUNCTION OF ATOMIC NUMBER ATNO ***
  // *** AND KINETIC ENERGY EKIN OF PRIMARY PARTICLE ***
  // *** NVE 04-MAR-1988 CERN GENEVA ***
  // ORIGIN : H.FESEFELDT (10-DEC-1986)

  ret_val = G4float(0.);
  if (targetAtomicMass >= G4float(1.5)) {
    magic = 0;
    if (G4int(targetCharge + G4float(.1)) == 82) {
      magic = 1;
    }
    ekin1 = ek1;
    if (ekin1 < G4float(.1)) {
      ekin1 = G4float(.1);
    }
    if (ekin1 > G4float(4.)) {
      ekin1 = G4float(4.);
    }
    // **   0.35 VALUE AT 1 GEV
    // **   0.05 VALUE AT 0.1 GEV
    cfa = G4float(.13043478260869565);
    cfa = cfa * G4Log(ekin1) + G4float(.35);
    if (cfa < G4float(.15)) {
      cfa = G4float(.15);
    }
    ret_val = cfa * G4float(7.716) * G4Exp(-G4double(cfa));
    atno3 = targetAtomicMass;
    if (atno3 > G4float(120.)) {
      atno3 = G4float(120.);
    }
    cfa = (atno3 - G4float(1.)) /
      G4float(120.) * G4Exp(-G4double(atno3 - G4float(1.)) / G4float(120.));
    ret_val *= cfa;
    r__1 = ekin1;
    fpdiv = G4float(1.) - r__1 * r__1 * G4float(.25);
    if (fpdiv < G4float(.5)) {
      fpdiv = G4float(.5);
    }
    gfa = (targetAtomicMass - G4float(1.)) /
      G4float(70.) * G4float(2.) *
      G4Exp(-G4double(targetAtomicMass - G4float(1.)) / G4float(70.));
    evapEnergy1 = ret_val * fpdiv;
    evapEnergy3 = ret_val - evapEnergy1;
    Normal(&ran1);
    Normal(&ran2);
    if (magic == 1) {
      ran1 = G4float(0.);
      ran2 = G4float(0.);
    }
    evapEnergy1 *= ran1 * gfa + G4float(1.);
    if (evapEnergy1 < G4float(0.)) {
      evapEnergy1 = G4float(0.);
    }
    evapEnergy3 *= ran2 * gfa + G4float(1.);
    if (evapEnergy3 < G4float(0.)) {
      evapEnergy3 = G4float(0.);
    }

    // Loop checking, 06-Aug-2015, Vladimir Ivanchenko
    while ((ret_val = evapEnergy1 + evapEnergy3) >= ek1) {
      evapEnergy1 *= G4float(1.) - G4UniformRand() * G4float(.5);
      evapEnergy3 *= G4float(1.) - G4UniformRand() * G4float(.5);
    }
  }
  return ret_val;

} // ExNu

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateSecondaries()

void G4AntiNeutronAnnihilationAtRest::GenerateSecondaries ( )

private

Definition at line 239 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  static G4ThreadLocal G4int index;
  static G4ThreadLocal G4int l;
  static G4ThreadLocal G4int nopt;
  static G4ThreadLocal G4int i;
  // DHW 15 May 2011: unused: static G4ParticleDefinition* jnd;

  for (i = 1; i <= MAX_SECONDARIES; ++i) {
    pv[i].SetZero();
  }


  ngkine = 0;            // number of generated secondary particles
  ntot = 0;
  result.SetZero();
  result.SetMass( massAntiNeutron );
  result.SetKineticEnergyAndUpdate( 0. );
  result.SetTOF( 0. );
  result.SetParticleDef( pdefAntiNeutron );

  // *** SELECT PROCESS FOR CURRENT PARTICLE ***

  AntiNeutronAnnihilation(&nopt);

  // *** CHECK WHETHER THERE ARE NEW PARTICLES GENERATED ***
  if (ntot != 0 || result.GetParticleDef() != pdefAntiNeutron) {
    // *** CURRENT PARTICLE IS NOT THE SAME AS IN THE BEGINNING OR/AND ***
    // *** ONE OR MORE SECONDARIES HAVE BEEN GENERATED ***

    // --- INITIAL PARTICLE TYPE HAS BEEN CHANGED ==> PUT NEW TYPE ON ---
    // --- THE GEANT TEMPORARY STACK ---

    // --- PUT PARTICLE ON THE STACK ---
    gkin[0] = result;
    gkin[0].SetTOF( result.GetTOF() * 5e-11 );
    ngkine = 1;

    // --- ALL QUANTITIES ARE TAKEN FROM THE GHEISHA STACK WHERE THE ---
    // --- CONVENTION IS THE FOLLOWING ---

    // --- ONE OR MORE SECONDARIES HAVE BEEN GENERATED ---
    for (l = 1; l <= ntot; ++l) {
      index = l - 1;
      // DHW  15 May 2011: unused: jnd = eve[index].GetParticleDef();

      // --- ADD PARTICLE TO THE STACK IF STACK NOT YET FULL ---
      if (ngkine < MAX_SECONDARIES) {
    gkin[ngkine] = eve[index];
    gkin[ngkine].SetTOF( eve[index].GetTOF() * 5e-11 );
    ++ngkine;
      }
    }
  }
  else {
    // --- NO SECONDARIES GENERATED AND PARTICLE IS STILL THE SAME ---
    // --- ==> COPY EVERYTHING BACK IN THE CURRENT GEANT STACK ---
    ngkine = 0;
    ntot = 0;
    globalTime += result.GetTOF() * G4float(5e-11);
  }

  // --- LIMIT THE VALUE OF NGKINE IN CASE OF OVERFLOW ---
  ngkine = G4int(std::min(ngkine,G4int(MAX_SECONDARIES)));

} // GenerateSecondaries

Here is the call graph for this function:

Here is the caller graph for this function:

GetMeanLifeTime()

G4double G4AntiNeutronAnnihilationAtRest::GetMeanLifeTime ( const G4Track &  , G4ForceCondition *    )

inlinevirtual

Implements G4VRestProcess.

Definition at line 72 of file G4AntiNeutronAnnihilationAtRest.hh.

                                      {return 0.0;}

Here is the call graph for this function:

Here is the caller graph for this function:

GetNumberOfSecondaries()

G4int G4AntiNeutronAnnihilationAtRest::GetNumberOfSecondaries

(

)

Definition at line 112 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  return ( ngkine );

}

Here is the caller graph for this function:

GetSecondaryKinematics()

G4GHEKinematicsVector * G4AntiNeutronAnnihilationAtRest::GetSecondaryKinematics

(

)

Definition at line 119 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  return ( &gkin[0] );

}

Here is the caller graph for this function:

IsApplicable()

G4bool G4AntiNeutronAnnihilationAtRest::IsApplicable ( const G4ParticleDefinition &  particle )

virtual

Reimplemented from G4VProcess.

Definition at line 103 of file G4AntiNeutronAnnihilationAtRest.cc.

{
   return ( &particle == pdefAntiNeutron );

}

NFac()

G4int G4AntiNeutronAnnihilationAtRest::NFac ( G4int  n )

private

Definition at line 382 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  G4int ret_val;

  static G4ThreadLocal G4int i, j;

  // *** NVE 16-MAR-1988 CERN GENEVA ***
  // ORIGIN : H.FESEFELDT (27-OCT-1983)

  ret_val = 1;
  j = n;
  if (j > 1) {
    if (j > 10) {
      j = 10;
    }
    for (i = 2; i <= j; ++i) {
      ret_val *= i;
    }
  }
  return ret_val;

} // NFac

Here is the caller graph for this function:

Normal()

void G4AntiNeutronAnnihilationAtRest::Normal ( G4float *  ran )

private

Definition at line 406 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  static G4ThreadLocal G4int i;

  // *** NVE 14-APR-1988 CERN GENEVA ***
  // ORIGIN : H.FESEFELDT (27-OCT-1983)

  *ran = G4float(-6.);
  for (i = 1; i <= 12; ++i) {
    *ran += G4UniformRand();
  }

} // Normal

Here is the caller graph for this function:

operator=()

G4AntiNeutronAnnihilationAtRest& G4AntiNeutronAnnihilationAtRest::operator= ( const G4AntiNeutronAnnihilationAtRest &  right )

private

Poisso()

void G4AntiNeutronAnnihilationAtRest::Poisso ( G4float  xav, G4int *  iran  )

private

Definition at line 307 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  static G4ThreadLocal G4int i;
  static G4ThreadLocal G4float r, p1, p2, p3;
  static G4ThreadLocal G4int fivex;
  static G4ThreadLocal G4float rr, ran, rrr, ran1;

  // *** GENERATION OF POISSON DISTRIBUTION ***
  // *** NVE 16-MAR-1988 CERN GENEVA ***
  // ORIGIN : H.FESEFELDT (27-OCT-1983)

  // --- USE NORMAL DISTRIBUTION FOR <X> > 9.9 ---
  if (xav > G4float(9.9)) {
    // ** NORMAL DISTRIBUTION WITH SIGMA**2 = <X>
    Normal(&ran1);
    ran1 = xav + ran1 * std::sqrt(xav);
    *iran = G4int(ran1);
    if (*iran < 0) {
      *iran = 0;
    }
  }
  else {
    fivex = G4int(xav * G4float(5.));
    *iran = 0;
    if (fivex > 0) {
      r = G4Exp(-G4double(xav));
      ran1 = G4UniformRand();
      if (ran1 > r) {
    rr = r;
    for (i = 1; i <= fivex; ++i) {
      ++(*iran);
      if (i <= 5) {
        rrr = G4Pow::GetInstance()->powN(xav, i) / NFac(i);
      }
      // ** STIRLING' S FORMULA FOR LARGE NUMBERS
      if (i > 5) {
        rrr = G4Exp(i * G4Log(xav) -
              (i + G4float(.5)) * G4Log(i * G4float(1.)) +
              i - G4float(.9189385));
      }
      rr += r * rrr;
      if (ran1 <= rr) {
        break;
      }
    }
      }
    }
    else {
      // ** FOR VERY SMALL XAV TRY IRAN=1,2,3
      p1 = xav * G4Exp(-G4double(xav));
      p2 = xav * p1 / G4float(2.);
      p3 = xav * p2 / G4float(3.);
      ran = G4UniformRand();
      if (ran >= p3) {
    if (ran >= p2) {
      if (ran >= p1) {
        *iran = 0;
      }
      else {
        *iran = 1;
      }
    }
    else {
      *iran = 2;
    }
      }
      else {
    *iran = 3;
      }
    }
  }

} // Poisso

Here is the call graph for this function:

Here is the caller graph for this function:

PreparePhysicsTable()

void G4AntiNeutronAnnihilationAtRest::PreparePhysicsTable ( const G4ParticleDefinition &  p )

virtual

Reimplemented from G4VProcess.

Definition at line 91 of file G4AntiNeutronAnnihilationAtRest.cc.

{
  G4HadronicProcessStore::Instance()->RegisterParticleForExtraProcess(this, &p);
}

Here is the call graph for this function:

Member Data Documentation

evapEnergy1

G4float G4AntiNeutronAnnihilationAtRest::evapEnergy1

private

Definition at line 107 of file G4AntiNeutronAnnihilationAtRest.hh.

evapEnergy3

G4float G4AntiNeutronAnnihilationAtRest::evapEnergy3

private

Definition at line 108 of file G4AntiNeutronAnnihilationAtRest.hh.

eve

G4GHEKinematicsVector* G4AntiNeutronAnnihilationAtRest::eve

private

Definition at line 104 of file G4AntiNeutronAnnihilationAtRest.hh.

gkin

G4GHEKinematicsVector* G4AntiNeutronAnnihilationAtRest::gkin

private

Definition at line 105 of file G4AntiNeutronAnnihilationAtRest.hh.

globalTime

G4float G4AntiNeutronAnnihilationAtRest::globalTime

private

Definition at line 95 of file G4AntiNeutronAnnihilationAtRest.hh.

massAntiNeutron

G4float G4AntiNeutronAnnihilationAtRest::massAntiNeutron

private

Definition at line 119 of file G4AntiNeutronAnnihilationAtRest.hh.

massGamma

G4float G4AntiNeutronAnnihilationAtRest::massGamma

private

Definition at line 118 of file G4AntiNeutronAnnihilationAtRest.hh.

massNeutron

G4float G4AntiNeutronAnnihilationAtRest::massNeutron

private

Definition at line 120 of file G4AntiNeutronAnnihilationAtRest.hh.

massPionMinus

G4float G4AntiNeutronAnnihilationAtRest::massPionMinus

private

Definition at line 115 of file G4AntiNeutronAnnihilationAtRest.hh.

massPionPlus

G4float G4AntiNeutronAnnihilationAtRest::massPionPlus

private

Definition at line 117 of file G4AntiNeutronAnnihilationAtRest.hh.

massPionZero

G4float G4AntiNeutronAnnihilationAtRest::massPionZero

private

Definition at line 116 of file G4AntiNeutronAnnihilationAtRest.hh.

ngkine

G4int G4AntiNeutronAnnihilationAtRest::ngkine

private

Definition at line 110 of file G4AntiNeutronAnnihilationAtRest.hh.

ntot

G4int G4AntiNeutronAnnihilationAtRest::ntot

private

Definition at line 112 of file G4AntiNeutronAnnihilationAtRest.hh.

pdefAlpha

G4ParticleDefinition* G4AntiNeutronAnnihilationAtRest::pdefAlpha

private

Definition at line 131 of file G4AntiNeutronAnnihilationAtRest.hh.

pdefAntiNeutron

G4ParticleDefinition* G4AntiNeutronAnnihilationAtRest::pdefAntiNeutron

private

Definition at line 128 of file G4AntiNeutronAnnihilationAtRest.hh.

pdefDeuteron

G4ParticleDefinition* G4AntiNeutronAnnihilationAtRest::pdefDeuteron

private

Definition at line 129 of file G4AntiNeutronAnnihilationAtRest.hh.

pdefGamma

G4ParticleDefinition* G4AntiNeutronAnnihilationAtRest::pdefGamma

private

Definition at line 122 of file G4AntiNeutronAnnihilationAtRest.hh.

pdefNeutron

G4ParticleDefinition* G4AntiNeutronAnnihilationAtRest::pdefNeutron

private

Definition at line 127 of file G4AntiNeutronAnnihilationAtRest.hh.

pdefPionMinus

G4ParticleDefinition* G4AntiNeutronAnnihilationAtRest::pdefPionMinus

private

Definition at line 125 of file G4AntiNeutronAnnihilationAtRest.hh.

pdefPionPlus

G4ParticleDefinition* G4AntiNeutronAnnihilationAtRest::pdefPionPlus

private

Definition at line 123 of file G4AntiNeutronAnnihilationAtRest.hh.

pdefPionZero

G4ParticleDefinition* G4AntiNeutronAnnihilationAtRest::pdefPionZero

private

Definition at line 124 of file G4AntiNeutronAnnihilationAtRest.hh.

pdefProton

G4ParticleDefinition* G4AntiNeutronAnnihilationAtRest::pdefProton

private

Definition at line 126 of file G4AntiNeutronAnnihilationAtRest.hh.

pdefTriton

G4ParticleDefinition* G4AntiNeutronAnnihilationAtRest::pdefTriton

private

Definition at line 130 of file G4AntiNeutronAnnihilationAtRest.hh.

pv

G4GHEKinematicsVector* G4AntiNeutronAnnihilationAtRest::pv

private

Definition at line 103 of file G4AntiNeutronAnnihilationAtRest.hh.

result

G4GHEKinematicsVector G4AntiNeutronAnnihilationAtRest::result

private

Definition at line 113 of file G4AntiNeutronAnnihilationAtRest.hh.

targetAtomicMass

G4float G4AntiNeutronAnnihilationAtRest::targetAtomicMass

private

Definition at line 98 of file G4AntiNeutronAnnihilationAtRest.hh.

targetCharge

G4float G4AntiNeutronAnnihilationAtRest::targetCharge

private

Definition at line 101 of file G4AntiNeutronAnnihilationAtRest.hh.

---

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

• G4AntiNeutronAnnihilationAtRest.hh
• G4AntiNeutronAnnihilationAtRest.cc