G4INCL::PauliStandard Class Reference

#include <G4INCLPauliStandard.hh>

Inheritance diagram for G4INCL::PauliStandard:

Public Member Functions
	PauliStandard ()
	~PauliStandard ()
G4bool	isBlocked (ParticleList const, Nucleus const *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) const =0

Detailed Description

Definition at line 45 of file G4INCLPauliStandard.hh.

Constructor & Destructor Documentation

PauliStandard()

G4INCL::PauliStandard::PauliStandard

(

)

Definition at line 47 of file G4INCLPauliStandard.cc.

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

~PauliStandard()

G4INCL::PauliStandard::~PauliStandard

(

)

Definition at line 53 of file G4INCLPauliStandard.cc.

{}

Member Function Documentation

getBlockingProbability()

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

Definition at line 63 of file G4INCLPauliStandard.cc.

                                                                                                                     {
    const G4double r0 = nucleus->getDensity()->getNuclearRadius();
    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 particles = nucleus->getStore()->getParticles();
 
    G4int nl = 0;
    for(ParticleIter it = particles.begin(); it != particles.end(); ++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  ) const

virtual

Implements G4INCL::IPauli.

Definition at line 55 of file G4INCLPauliStandard.cc.

                                                                                      {
    for(ParticleIter p = pL.begin(); p != pL.end(); ++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