G4INCL::PauliStandard Class Reference

#include <G4INCLPauliStandard.hh>

Inheritance diagram for G4INCL::PauliStandard:

Public Member Functions
	PauliStandard ()
	~PauliStandard ()
G4bool	isBlocked (ParticleList const &, Nucleus const *const)
G4double	getBlockingProbability (Particle const *const, Nucleus const *const) const
Public Member Functions inherited from G4INCL::IPauli
	IPauli ()
virtual	~IPauli ()
virtual G4bool	isBlocked (ParticleList const &, Nucleus const *const)=0

Detailed Description

Definition at line 44 of file G4INCLPauliStandard.hh.

Constructor & Destructor Documentation

PauliStandard()

G4INCL::PauliStandard::PauliStandard

(

)

Definition at line 46 of file G4INCLPauliStandard.cc.

                               :
    cellSize(std::pow(2.38*4.5*Math::pi,1./6.)*std::sqrt(PhysicalConstants::hc))
  {
    INCL_DEBUG("Initialising PauliStandard. cellSize=" << cellSize << '\n');
  }

~PauliStandard()

G4INCL::PauliStandard::~PauliStandard

(

)

Definition at line 52 of file G4INCLPauliStandard.cc.

{}

Member Function Documentation

getBlockingProbability()

G4double G4INCL::PauliStandard::getBlockingProbability	(	Particle const * const	particle,
		Nucleus const * const	nucleus
	)		const

Definition at line 62 of file G4INCLPauliStandard.cc.

                                                                                                                     {
    const G4double r0 = ParticleTable::getNuclearRadius(particle->getType(), nucleus->getA(), nucleus->getZ());
    const G4double pFermi = nucleus->getPotential()->getFermiMomentum(particle);
 
    const G4double pbl = cellSize * std::sqrt(pFermi/r0);
    const G4double rbl = pbl * r0/pFermi;
    const G4double maxVolR = rbl;
    const G4double maxVolP = pbl;
    G4double vol = std::pow(4.*Math::pi/3.0, 2)
      * std::pow(maxVolR*maxVolP/(Math::twoPi*PhysicalConstants::hc), 3);
 
    const G4double rdeq = nucleus->getUniverseRadius();
    const G4double rs = particle->getPosition().mag();
 
    if(rs - maxVolR > rdeq) {
      return 0.0;
    }
 
    if(rs + maxVolR > rdeq) {
      vol = vol * 0.5 * (rdeq - rs + maxVolR) / maxVolR;
    }
 
    // Get the list of particles that are currently inside the
    // nucleus.
    ParticleList const &particles = nucleus->getStore()->getParticles();
 
    G4int nl = 0;
    for(ParticleIter it=particles.begin(), e=particles.end(); it!=e; ++it) {
      // Skip comparing with the same particle
      if( (*it)->getID() == particle->getID() ) continue;
 
      if((*it)->getType() == particle->getType()) {
        const ThreeVector dx2v = particle->getPosition() - (*it)->getPosition();
        const G4double dx2 = dx2v.mag2();
        if(dx2 > maxVolR * maxVolR) continue;
 
        const ThreeVector dp2v = particle->getMomentum() - (*it)->getMomentum();
        const G4double dp2 = dp2v.mag2();
        if(dp2 > maxVolP * maxVolP) continue;
 
        nl++;
      }
    }
    const G4double blockingProbability = ((G4double) nl) / vol / 2.0;
 
    if(blockingProbability > 1.0) return 1.0;
    else if(blockingProbability < 0.0) return 0.0;
    else return blockingProbability;
  }

Referenced by isBlocked().

isBlocked()

G4bool G4INCL::PauliStandard::isBlocked ( ParticleList const &  pL, Nucleus const * const  n  )

virtual

Implements G4INCL::IPauli.

Definition at line 54 of file G4INCLPauliStandard.cc.

                                                                                 {
    for(ParticleIter p=pL.begin(), e=pL.end(); p!=e; ++p) {
      if( !(*p)->isNucleon() ) continue;
      if(getBlockingProbability(*p, n) > Random::shoot()) return true;
    }
    return false;
  }

---

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

• G4INCLPauliStandard.hh
• G4INCLPauliStandard.cc