G4INCL::SurfaceAvatar Class Reference

#include <G4INCLSurfaceAvatar.hh>

Inheritance diagram for G4INCL::SurfaceAvatar:

Public Member Functions
	SurfaceAvatar (G4INCL::Particle *aParticle, G4double time, G4INCL::Nucleus *aNucleus)
virtual	~SurfaceAvatar ()
IChannel *	getChannel ()
void	fillFinalState (FinalState *fs)
virtual void	preInteraction ()
virtual void	postInteraction (FinalState *)
ParticleList	getParticles () const
std::string	dump () const
G4double	getTransmissionProbability (Particle const *const particle)
	Calculate the transmission probability for the particle.
G4double	getCosRefractionAngle () const
	Get the cosine of the refraction angle (precalculated by initializeRefractionVariables)
G4double	getOutgoingMomentum () const
	Get the outgoing momentum (precalculated by initializeRefractionVariables)
Public Member Functions inherited from G4INCL::IAvatar
	IAvatar ()
	IAvatar (G4double time)
virtual	~IAvatar ()
virtual G4INCL::IChannel *	getChannel ()=0
FinalState *	getFinalState ()
void	fillFinalState (FinalState *fs)
virtual void	preInteraction ()=0
virtual void	postInteraction (FinalState *)=0
G4double	getTime () const
virtual ParticleList	getParticles () const =0
virtual std::string	dump () const =0
AvatarType	getType () const
G4bool	isACollision () const
G4bool	isADecay () const
void	setType (AvatarType t)
long	getID () const
std::string	toString ()

Additional Inherited Members
Protected Attributes inherited from G4INCL::IAvatar
G4double	theTime

Detailed Description

Surface avatar

The reflection avatar is created when a particle reaches the boundary of the nucleus. At this point it can either be reflected from the boundary or exit the nucleus.

Definition at line 62 of file G4INCLSurfaceAvatar.hh.

Constructor & Destructor Documentation

SurfaceAvatar()

G4INCL::SurfaceAvatar::SurfaceAvatar	(	G4INCL::Particle *	aParticle,
		G4double	time,
		G4INCL::Nucleus *	aNucleus
	)

Definition at line 55 of file G4INCLSurfaceAvatar.cc.

    :IAvatar(time), theParticle(aParticle), theNucleus(n),
    particlePIn(0.),
    particlePOut(0.),
    particleTOut(0.),
    TMinusV(0.),
    TMinusV2(0.),
    particleMass(0.),
    sinIncidentAngle(0.),
    cosIncidentAngle(0.),
    sinRefractionAngle(0.),
    cosRefractionAngle(0.),
    refractionIndexRatio(0.),
    internalReflection(false)
  {
    setType(SurfaceAvatarType);
  }

~SurfaceAvatar()

G4INCL::SurfaceAvatar::~SurfaceAvatar ( )

virtual

Definition at line 73 of file G4INCLSurfaceAvatar.cc.

  {
  }

Member Function Documentation

dump()

std::string G4INCL::SurfaceAvatar::dump ( ) const

virtual

Implements G4INCL::IAvatar.

Definition at line 194 of file G4INCLSurfaceAvatar.cc.

                                      {
    std::stringstream ss;
    ss << "(avatar " << theTime << " 'reflection" << '\n'
      << "(list " << '\n'
      << theParticle->dump()
      << "))" << '\n';
    return ss.str();
  }

fillFinalState()

void G4INCL::SurfaceAvatar::fillFinalState

(

FinalState *

fs

)

Definition at line 167 of file G4INCLSurfaceAvatar.cc.

                                                   {
    getChannel()->fillFinalState(fs);
  }

getChannel()

G4INCL::IChannel * G4INCL::SurfaceAvatar::getChannel ( )

virtual

Implements G4INCL::IAvatar.

Definition at line 77 of file G4INCLSurfaceAvatar.cc.

                                            {
    if(theParticle->isTargetSpectator()) {
      INCL_DEBUG("Particle " << theParticle->getID() << " is a spectator, reflection" << '\n');
      return new ReflectionChannel(theNucleus, theParticle);
    }
 
    // We forbid transmission of resonances below the Fermi energy. Emitting a
    // delta particle below Tf can lead to negative excitation energies, since
    // CDPP assumes that particles stay in the Fermi sea.
    if(theParticle->isResonance()) {
      const G4double theFermiEnergy = theNucleus->getPotential()->getFermiEnergy(theParticle);
      if(theParticle->getKineticEnergy()<theFermiEnergy) {
        INCL_DEBUG("Particle " << theParticle->getID() << " is a resonance below Tf, reflection" << '\n'
            << "  Tf=" << theFermiEnergy << ", EKin=" << theParticle->getKineticEnergy() << '\n');
        return new ReflectionChannel(theNucleus, theParticle);
      }
    }
 
    // Don't try to make a cluster if the leading particle is too slow
    const G4double transmissionProbability = getTransmissionProbability(theParticle);
    const G4double TOut = TMinusV;
    const G4double kOut = particlePOut;
    const G4double cosR = cosRefractionAngle;
 
    INCL_DEBUG("Transmission probability for particle " << theParticle->getID() << " = " << transmissionProbability << '\n');
    /* Don't attempt to construct clusters when a projectile spectator is
     * trying to escape during a nucleus-nucleus collision. The idea behind
     * this is that projectile spectators will later be collected in the
     * projectile remnant, and trying to clusterise them somewhat feels like
     * G4double counting. Moreover, applying the clustering algorithm on escaping
     * projectile spectators makes the code *really* slow if the projectile is
     * large.
     */
    if(theParticle->isNucleonorLambda()
        && (!theParticle->isProjectileSpectator() || !theNucleus->isNucleusNucleusCollision())
        && transmissionProbability>1.E-4) {
      Cluster *candidateCluster = 0;
 
      candidateCluster = Clustering::getCluster(theNucleus, theParticle);
      if(candidateCluster != 0 &&
          Clustering::clusterCanEscape(theNucleus, candidateCluster)) {
 
        INCL_DEBUG("Cluster algorithm succeeded. Candidate cluster:" << '\n' << candidateCluster->print() << '\n');
 
        // Check if the cluster can penetrate the Coulomb barrier
        const G4double clusterTransmissionProbability = getTransmissionProbability(candidateCluster);
        const G4double x = Random::shoot();
 
        INCL_DEBUG("Transmission probability for cluster " << candidateCluster->getID() << " = " << clusterTransmissionProbability << '\n');
 
        if (x <= clusterTransmissionProbability) {
          theNucleus->getStore()->getBook().incrementEmittedClusters();
          INCL_DEBUG("Cluster " << candidateCluster->getID() << " passes the Coulomb barrier, transmitting." << '\n');
          return new TransmissionChannel(theNucleus, candidateCluster);
        } else {
          INCL_DEBUG("Cluster " << candidateCluster->getID() << " does not pass the Coulomb barrier. Falling back to transmission of the leading particle." << '\n');
          delete candidateCluster;
        }
      } else {
        delete candidateCluster;
      }
    }
 
    // If we haven't transmitted a cluster (maybe cluster feature was
    // disabled or maybe we just can't produce an acceptable cluster):
 
    // Always transmit projectile spectators if no cluster was formed and if
    // transmission is energetically allowed
    if(theParticle->isProjectileSpectator() && transmissionProbability>0.) {
      INCL_DEBUG("Particle " << theParticle->getID() << " is a projectile spectator, transmission" << '\n');
      return new TransmissionChannel(theNucleus, theParticle, TOut);
    }
 
    // Transmit or reflect depending on the transmission probability
    const G4double x = Random::shoot();
 
    if(x <= transmissionProbability) { // Transmission
      INCL_DEBUG("Particle " << theParticle->getID() << " passes the Coulomb barrier, transmitting." << '\n');
      if(theParticle->isKaon()) theNucleus->setNumberOfKaon(theNucleus->getNumberOfKaon()-1);
      if(theNucleus->getStore()->getConfig()->getRefraction()) {
        return new TransmissionChannel(theNucleus, theParticle, kOut, cosR);
      } else {
        return new TransmissionChannel(theNucleus, theParticle, TOut);
      }
    } else { // Reflection
      INCL_DEBUG("Particle " << theParticle->getID() << " does not pass the Coulomb barrier, reflection." << '\n');
      return new ReflectionChannel(theNucleus, theParticle);
    }
  }

Referenced by fillFinalState().

getCosRefractionAngle()

G4double G4INCL::SurfaceAvatar::getCosRefractionAngle ( ) const

inline

Get the cosine of the refraction angle (precalculated by initializeRefractionVariables)

Definition at line 85 of file G4INCLSurfaceAvatar.hh.

{ return cosRefractionAngle; }

getOutgoingMomentum()

G4double G4INCL::SurfaceAvatar::getOutgoingMomentum ( ) const

inline

Get the outgoing momentum (precalculated by initializeRefractionVariables)

Definition at line 88 of file G4INCLSurfaceAvatar.hh.

{ return particlePOut; }

getParticles()

ParticleList G4INCL::SurfaceAvatar::getParticles ( ) const

inlinevirtual

Implements G4INCL::IAvatar.

Definition at line 73 of file G4INCLSurfaceAvatar.hh.

                                      {
      ParticleList theParticleList;
      theParticleList.push_back(theParticle);
      return theParticleList;
    }

getTransmissionProbability()

G4double G4INCL::SurfaceAvatar::getTransmissionProbability

(

Particle const *const

particle

)

Calculate the transmission probability for the particle.

Definition at line 203 of file G4INCLSurfaceAvatar.cc.

                                                                                    {
 
    particleMass = particle->getMass();
    const G4double V = particle->getPotentialEnergy();
 
    // Correction to the particle kinetic energy if using real masses
    const G4int theA = theNucleus->getA();
    const G4int theZ = theNucleus->getZ();
    const G4int theS = theNucleus->getS();
    const G4double correction = particle->getEmissionQValueCorrection(theA, theZ, theS);
    particleTOut = particle->getKineticEnergy() + correction;
 
    if (particleTOut <= V) // No transmission if total energy < 0
      return 0.0;
 
    TMinusV = particleTOut-V;
    TMinusV2 = TMinusV*TMinusV;
 
    // Momenta in and out
    const G4double particlePIn2  = particle->getMomentum().mag2();
    const G4double particlePOut2 = 2.*particleMass*TMinusV+TMinusV2;
    particlePIn  = std::sqrt(particlePIn2);
    particlePOut = std::sqrt(particlePOut2);
    
    if (0. > V) // Automatic transmission for repulsive potential
      return 1.0;
 
    // Compute the transmission probability
    G4double theTransmissionProbability;
    if(theNucleus->getStore()->getConfig()->getRefraction()) {
      // Use the formula with refraction
      initializeRefractionVariables(particle);
 
      if(internalReflection)
        return 0.; // total internal reflection
 
      // Intermediate variables for calculation
      const G4double x = refractionIndexRatio*cosIncidentAngle;
      const G4double y = (x - cosRefractionAngle) / (x + cosRefractionAngle);
 
      theTransmissionProbability = 1. - y*y;
    } else {
      // Use the formula without refraction
      // Intermediate variable for calculation
      const G4double y = particlePIn+particlePOut;
 
      // The transmission probability for a potential step
      theTransmissionProbability = 4.*particlePIn*particlePOut/(y*y);
    }
 
    // For neutral and negative particles, no Coulomb transmission
    // Also, no Coulomb if the particle takes away all of the nuclear charge
    const G4int particleZ = particle->getZ();
    if (particleZ <= 0 || particleZ >= theZ)
      return theTransmissionProbability;
 
    // Nominal Coulomb barrier
    const G4double theTransmissionBarrier = theNucleus->getTransmissionBarrier(particle);
    if (TMinusV >= theTransmissionBarrier) // Above the Coulomb barrier
      return theTransmissionProbability;
 
    // Coulomb-penetration factor
    const G4double px = std::sqrt(TMinusV/theTransmissionBarrier);
    const G4double logCoulombTransmission =
      particleZ*(theZ-particleZ)/137.03*std::sqrt(2.*particleMass/TMinusV/(1.+TMinusV/2./particleMass))
      *(Math::arcCos(px)-px*std::sqrt(1.-px*px));
    INCL_DEBUG("Coulomb barrier, logCoulombTransmission=" << logCoulombTransmission << '\n');
    if (logCoulombTransmission > 35.) // Transmission is forbidden by Coulomb
      return 0.;
    theTransmissionProbability *= std::exp(-2.*logCoulombTransmission);
 
    return theTransmissionProbability;
  }

Referenced by getChannel().

postInteraction()

void G4INCL::SurfaceAvatar::postInteraction ( FinalState *  fs )

virtual

Implements G4INCL::IAvatar.

Definition at line 173 of file G4INCLSurfaceAvatar.cc.

                                                    {
    ParticleList const &outgoing = fs->getOutgoingParticles();
    if(!outgoing.empty()) { // Transmission
// assert(outgoing.size()==1);
      Particle *out = outgoing.front();
      out->rpCorrelate();
      if(out->isCluster()) {
        Cluster *clusterOut = dynamic_cast<Cluster*>(out);
        ParticleList const &components = clusterOut->getParticles();
        for(ParticleIter i=components.begin(), e=components.end(); i!=e; ++i) {
          if(!(*i)->isTargetSpectator())
            theNucleus->getStore()->getBook().decrementCascading();
        }
        out->setBiasCollisionVector(components.getParticleListBiasVector());
      } else if(!theParticle->isTargetSpectator()) {
// assert(out==theParticle);
        theNucleus->getStore()->getBook().decrementCascading();
      }
    }
  }

preInteraction()

void G4INCL::SurfaceAvatar::preInteraction ( )

virtual

Implements G4INCL::IAvatar.

Definition at line 171 of file G4INCLSurfaceAvatar.cc.

{}

---

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

• G4INCLSurfaceAvatar.hh
• G4INCLSurfaceAvatar.cc