#include <G4INCLSurfaceAvatar.hh>

Inheritance diagram for G4INCL::SurfaceAvatar:

Public Member Functions
	SurfaceAvatar (G4INCL::Particle aParticle, G4double time, G4INCL::Nucleus aNucleus)

virtual	~SurfaceAvatar ()

G4INCL::IChannel *	getChannel ()

G4INCL::FinalState *	getFinalState ()

virtual void	preInteraction ()

virtual FinalState *	postInteraction (FinalState *)

ParticleList	getParticles () const

std::string	dump () const

G4double	getTransmissionProbability (Particle const *const particle)
	Calculate the transmission probability for the particle. More...

G4double	getCosRefractionAngle () const
	Get the cosine of the refraction angle (precalculated by initializeRefractionVariables) More...

G4double	getOutgoingMomentum () const
	Get the outgoing momentum (precalculated by initializeRefractionVariables) More...

Public Member Functions inherited from G4INCL::IAvatar
	IAvatar ()

	IAvatar (G4double time)

virtual	~IAvatar ()

G4INCL::FinalState *	getFinalState ()

G4double	getTime () const

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 60 of file G4INCLSurfaceAvatar.hh.

Constructor & Destructor Documentation

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

Definition at line 54 of file G4INCLSurfaceAvatar.cc.

References G4INCL::IAvatar::setType(), and G4INCL::SurfaceAvatarType.

     :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);
   }

G4INCL::SurfaceAvatar::~SurfaceAvatar ( )

virtual

Definition at line 72 of file G4INCLSurfaceAvatar.cc.

                                 {
 
   }

Member Function Documentation

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

virtual

Implements G4INCL::IAvatar.

Definition at line 192 of file G4INCLSurfaceAvatar.cc.

References G4INCL::Particle::dump(), and G4INCL::IAvatar::theTime.

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

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

virtual

Implements G4INCL::IAvatar.

Definition at line 76 of file G4INCLSurfaceAvatar.cc.

References G4INCL::Clustering::clusterCanEscape(), G4INCL::Store::getBook(), G4INCL::Clustering::getCluster(), G4INCL::Store::getConfig(), G4INCL::NuclearPotential::INuclearPotential::getFermiEnergy(), G4INCL::Particle::getID(), G4INCL::Particle::getKineticEnergy(), G4INCL::Nucleus::getPotential(), G4INCL::Config::getRefraction(), G4INCL::Nucleus::getStore(), getTransmissionProbability(), INCL_DEBUG, G4INCL::Book::incrementEmittedClusters(), G4INCL::Particle::isNucleon(), G4INCL::Nucleus::isNucleusNucleusCollision(), G4INCL::Particle::isProjectileSpectator(), G4INCL::Particle::isResonance(), G4INCL::Particle::isTargetSpectator(), G4INCL::Cluster::print(), G4INCL::Random::shoot(), and test::x.

Referenced by getFinalState().

                                             {
     if(theParticle->isTargetSpectator()) {
       INCL_DEBUG("Particle " << theParticle->getID() << " is a spectator, reflection" << std::endl);
       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" << std::endl
             << "  Tf=" << theFermiEnergy << ", EKin=" << theParticle->getKineticEnergy() << std::endl);
         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 << std::endl);
     /* 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->isNucleon()
         && (!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 succeded. Candidate cluster:" << std::endl << candidateCluster->print() << std::endl);
 
         // 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 << std::endl);
 
         if (x <= clusterTransmissionProbability) {
           theNucleus->getStore()->getBook().incrementEmittedClusters();
           INCL_DEBUG("Cluster " << candidateCluster->getID() << " passes the Coulomb barrier, transmitting." << std::endl);
           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." << std::endl);
           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" << std::endl);
       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." << std::endl);
       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." << std::endl);
       return new ReflectionChannel(theNucleus, theParticle);
     }
   }

G4double G4INCL::SurfaceAvatar::getCosRefractionAngle ( ) const

inline

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

Definition at line 83 of file G4INCLSurfaceAvatar.hh.

83 { return cosRefractionAngle; }

G4INCL::FinalState * G4INCL::SurfaceAvatar::getFinalState ( )

Definition at line 165 of file G4INCLSurfaceAvatar.cc.

References getChannel(), and G4INCL::IChannel::getFinalState().

                                                  {
     return getChannel()->getFinalState();
   }

G4double G4INCL::SurfaceAvatar::getOutgoingMomentum ( ) const

inline

Get the outgoing momentum (precalculated by initializeRefractionVariables)

Definition at line 86 of file G4INCLSurfaceAvatar.hh.

86 { return particlePOut; }

ParticleList G4INCL::SurfaceAvatar::getParticles ( ) const

inlinevirtual

Implements G4INCL::IAvatar.

Definition at line 71 of file G4INCLSurfaceAvatar.hh.

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

G4double G4INCL::SurfaceAvatar::getTransmissionProbability ( Particle const *const particle )

Calculate the transmission probability for the particle.

Definition at line 201 of file G4INCLSurfaceAvatar.cc.

References G4INCL::Particle::getA(), G4INCL::Store::getConfig(), G4INCL::Particle::getEmissionQValueCorrection(), G4INCL::Particle::getKineticEnergy(), G4INCL::Particle::getMass(), G4INCL::Particle::getMomentum(), G4INCL::Particle::getPotentialEnergy(), G4INCL::Config::getRefraction(), G4INCL::Nucleus::getStore(), G4INCL::Nucleus::getTransmissionBarrier(), G4INCL::Particle::getZ(), INCL_DEBUG, G4INCL::ThreeVector::mag2(), and test::x.

Referenced by getChannel().

                                                                                     {
 
     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 G4double correction = particle->getEmissionQValueCorrection(theA, theZ);
     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);
 
     // 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))
       *(std::acos(px)-px*std::sqrt(1.-px*px));
     INCL_DEBUG("Coulomb barrier, logCoulombTransmission=" << logCoulombTransmission << std::endl);
     if (logCoulombTransmission > 35.) // Transmission is forbidden by Coulomb
       return 0.;
     theTransmissionProbability *= std::exp(-2.*logCoulombTransmission);
 
     return theTransmissionProbability;
   }

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

virtual

Implements G4INCL::IAvatar.

Definition at line 171 of file G4INCLSurfaceAvatar.cc.

References G4INCL::Book::decrementCascading(), G4INCL::Store::getBook(), G4INCL::FinalState::getOutgoingParticles(), G4INCL::Cluster::getParticles(), G4INCL::Nucleus::getStore(), G4INCL::Particle::isCluster(), G4INCL::Particle::isTargetSpectator(), and G4INCL::Particle::rpCorrelate().

                                                            {
     ParticleList 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();
         }
       } else if(!theParticle->isTargetSpectator()) {
 // assert(out==theParticle);
         theNucleus->getStore()->getBook().decrementCascading();
       }
     }
     return fs;
   }

void G4INCL::SurfaceAvatar::preInteraction ( )

virtual

Implements G4INCL::IAvatar.

Definition at line 169 of file G4INCLSurfaceAvatar.cc.

169 {}

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation