G4Fissioner Class Reference

#include <G4Fissioner.hh>

Inheritance diagram for G4Fissioner:

Public Member Functions
	G4Fissioner ()
virtual	~G4Fissioner ()
void	collide (G4InuclParticle *bullet, G4InuclParticle *target, G4CollisionOutput &output)
Public Member Functions inherited from G4CascadeColliderBase
	G4CascadeColliderBase (const char *name, G4int verbose=0)
virtual	~G4CascadeColliderBase ()
virtual void	rescatter (G4InuclParticle *, G4KineticTrackVector *, G4V3DNucleus *, G4CollisionOutput &)
virtual void	setVerboseLevel (G4int verbose=0)
virtual void	setConservationChecks (G4bool doBalance=true)
Public Member Functions inherited from G4VCascadeCollider
	G4VCascadeCollider (const char *name, G4int verbose=0)
virtual	~G4VCascadeCollider ()
virtual void	collide (G4InuclParticle *bullet, G4InuclParticle *target, G4CollisionOutput &output)=0
virtual void	setVerboseLevel (G4int verbose=0)

Additional Inherited Members
Protected Member Functions inherited from G4CascadeColliderBase
virtual G4bool	useEPCollider (G4InuclParticle *bullet, G4InuclParticle *target) const
virtual G4bool	explosion (G4InuclNuclei *target) const
virtual G4bool	explosion (G4Fragment *target) const
virtual G4bool	explosion (G4int A, G4int Z, G4double excitation) const
virtual G4bool	inelasticInteractionPossible (G4InuclParticle *bullet, G4InuclParticle *target, G4double ekin) const
virtual G4bool	validateOutput (G4InuclParticle *bullet, G4InuclParticle *target, G4CollisionOutput &output)
virtual G4bool	validateOutput (G4InuclParticle *bullet, G4InuclParticle *target, const std::vector< G4InuclElementaryParticle > &particles)
virtual G4bool	validateOutput (G4InuclParticle *bullet, G4InuclParticle *target, const std::vector< G4InuclNuclei > &fragments)
Protected Member Functions inherited from G4VCascadeCollider
virtual void	setName (const char *name)
Protected Attributes inherited from G4CascadeColliderBase
G4InteractionCase	interCase
G4bool	doConservationChecks
G4CascadeCheckBalance *	balance
Protected Attributes inherited from G4VCascadeCollider
const char *	theName
G4int	verboseLevel

Detailed Description

Definition at line 47 of file G4Fissioner.hh.

Constructor & Destructor Documentation

G4Fissioner()

G4Fissioner::G4Fissioner

(

)

Definition at line 58 of file G4Fissioner.cc.

: G4CascadeColliderBase("G4Fissioner") {}

~G4Fissioner()

virtual G4Fissioner::~G4Fissioner ( )

inlinevirtual

Definition at line 50 of file G4Fissioner.hh.

{}

Member Function Documentation

collide()

void G4Fissioner::collide ( G4InuclParticle *  bullet, G4InuclParticle *  target, G4CollisionOutput &  output  )

virtual

Implements G4VCascadeCollider.

Definition at line 60 of file G4Fissioner.cc.

                                         {
  if (verboseLevel) {
    G4cout << " >>> G4Fissioner::collide" << G4endl;
  }
 
  //  const G4int itry_max = 1000;
 
  G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target);
  if (!nuclei_target) {
    G4cerr << " >>> G4Fissioner -> target is not nuclei " << G4endl;
    return;
  }
 
  if (verboseLevel > 1) 
    G4cout << " Fissioner input\n" << *nuclei_target << G4endl;
 
  // Initialize buffer for fission possibilities
  fissionStore.setVerboseLevel(verboseLevel);
  fissionStore.clear();
 
  G4int A = nuclei_target->getA();
  G4int Z = nuclei_target->getZ();
 
  G4double EEXS = nuclei_target->getExitationEnergy();
  G4double mass_in = nuclei_target->getMass();
  G4double e_in = mass_in;      // Mass includes excitation
  G4double PARA = 0.055 * G4cbrt(A*A) * (G4cbrt(A-Z) + G4cbrt(Z));
  G4double TEM = std::sqrt(EEXS / PARA);
  G4double TETA = 0.494 * G4cbrt(A) * TEM;
  
  TETA = TETA / std::sinh(TETA);
  
  if (A < 246) PARA += (nucleiLevelDensity(A) - PARA) * TETA;
  
  G4int A1 = A/2 + 1;
  G4int Z1;
  G4int A2 = A - A1;
 
  G4double ALMA = -1000.0;
  G4double DM1 = bindingEnergy(A,Z);
  G4double EVV = EEXS - DM1;
  G4double DM2 = bindingEnergyAsymptotic(A, Z);
  G4double DTEM = (A < 220 ? 0.5 : 1.15);
  
  TEM += DTEM;
  
  G4double AL1[2] = { -0.15, -0.15 };
  G4double BET1[2] = { 0.05, 0.05 };
 
  G4double R12 = G4cbrt(A1) + G4cbrt(A2); 
  
  for (G4int i = 0; i < 50 && A1 > 30; i++) {
    A1--;
    A2 = A - A1;
    G4double X3 = 1.0 / G4cbrt(A1);
    G4double X4 = 1.0 / G4cbrt(A2);
    Z1 = G4lrint(getZopt(A1, A2, Z, X3, X4, R12) - 1.);
    G4double EDEF1[2];
    G4int Z2 = Z - Z1;
    G4double VPOT, VCOUL;
    
    potentialMinimization(VPOT, EDEF1, VCOUL, A1, A2, Z1, Z2, AL1, BET1, R12);
    
    G4double DM3 = bindingEnergy(A1,Z1);
    G4double DM4 = bindingEnergyAsymptotic(A1, Z1);
    G4double DM5 = bindingEnergy(A2,Z2);
    G4double DM6 = bindingEnergyAsymptotic(A2, Z2);
    G4double DMT1 = DM4 + DM6 - DM2;
    G4double DMT = DM3 + DM5 - DM1;
    G4double EZL = EEXS + DMT - VPOT;
    
    if(EZL > 0.0) { // generate fluctuations
      //  faster, using randomGauss
      G4double C1 = std::sqrt(getC2(A1, A2, X3, X4, R12) / TEM);
      G4double DZ = randomGauss(C1);
      
      DZ = DZ > 0.0 ? DZ + 0.5 : -std::fabs(DZ - 0.5);
      Z1 += G4int(DZ);
      Z2 -= G4int(DZ);
      
      G4double DEfin = randomGauss(TEM);    
      G4double EZ = (DMT1 + (DMT - DMT1) * TETA - VPOT + DEfin) / TEM;
      
      if (EZ >= ALMA) ALMA = EZ;
      G4double EK = VCOUL + DEfin + 0.5 * TEM;
      G4double EV = EVV + bindingEnergy(A1,Z1) + bindingEnergy(A2,Z2) - EK;
      
      if (EV > 0.0) fissionStore.addConfig(A1, Z1, EZ, EK, EV);
    };
  };
  
  G4int store_size = fissionStore.size();
  if (store_size == 0) return;      // No fission products
 
  G4FissionConfiguration config = 
    fissionStore.generateConfiguration(ALMA, inuclRndm());
  
  A1 = G4int(config.afirst);
  A2 = A - A1;
  Z1 = G4int(config.zfirst);
  
  G4int Z2 = Z - Z1;
  
  G4double mass1 = G4InuclNuclei::getNucleiMass(A1,Z1);
  G4double mass2 = G4InuclNuclei::getNucleiMass(A2,Z2);
  G4double EK = config.ekin;
  G4double pmod = std::sqrt(0.001 * EK * mass1 * mass2 / mass_in);
  
  G4LorentzVector mom1 = generateWithRandomAngles(pmod, mass1);
  G4LorentzVector mom2; mom2.setVectM(-mom1.vect(), mass2);
  
  G4double e_out = mom1.e() + mom2.e();
  G4double EV = 1000.0 * (e_in - e_out) / A;
  if (EV <= 0.0) return;        // No fission energy
 
  G4double EEXS1 = EV*A1;
  G4double EEXS2 = EV*A2;
 
  G4InuclNuclei nuclei1(mom1, A1, Z1, EEXS1, G4InuclParticle::Fissioner);
  G4InuclNuclei nuclei2(mom2, A2, Z2, EEXS2, G4InuclParticle::Fissioner);
 
  // Pass only last two nuclear fragments
  static std::vector<G4InuclNuclei> frags(2);       // Always the same size!
  frags[0] = nuclei1;
  frags[1] = nuclei2;
  validateOutput(0, target, frags);     // Check energy conservation
 
  output.addOutgoingNuclei(frags);
}

Referenced by G4EquilibriumEvaporator::collide().

---

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

• G4Fissioner.hh
• G4Fissioner.cc