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 ()
G4INCL::IChannel *	getChannel () const
G4INCL::FinalState *	getFinalState () const
virtual void	preInteraction ()
virtual FinalState *	postInteraction (FinalState *)
ParticleList	getParticles () const
std::string	dump () const
G4double	getTransmissionProbability (Particle const *const particle) const
	Calculate the transmission probability for the particle.
Public Member Functions inherited from G4INCL::IAvatar
	IAvatar ()
	IAvatar (G4double time)
virtual	~IAvatar ()
virtual G4INCL::IChannel *	getChannel () const =0
G4INCL::FinalState *	getFinalState ()
virtual void	preInteraction ()=0
virtual FinalState *	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 56 of file G4INCLSurfaceAvatar.cc.

    :IAvatar(time), theParticle(aParticle), theNucleus(n)
  {
    setType(SurfaceAvatarType);
  }

~SurfaceAvatar()

G4INCL::SurfaceAvatar::~SurfaceAvatar ( )

virtual

Definition at line 62 of file G4INCLSurfaceAvatar.cc.

                                {
 
  }

Member Function Documentation

dump()

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

virtual

Implements G4INCL::IAvatar.

Definition at line 175 of file G4INCLSurfaceAvatar.cc.

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

getChannel()

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

virtual

Implements G4INCL::IAvatar.

Definition at line 66 of file G4INCLSurfaceAvatar.cc.

  {
    if(theParticle->isTargetSpectator()) {
      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) {
        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);
 
    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)) {
 
        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();
 
        DEBUG("Transmission probability for cluster " << candidateCluster->getID() << " = " << clusterTransmissionProbability << std::endl);
 
        if (x <= clusterTransmissionProbability) {
          DEBUG("Cluster " << candidateCluster->getID() << " passes the Coulomb barrier, transmitting." << std::endl);
          return new TransmissionChannel(theNucleus, candidateCluster);
        } else {
          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.) {
      DEBUG("Particle " << theParticle->getID() << " is a projectile spectator, transmission" << std::endl);
      return new TransmissionChannel(theNucleus, theParticle);
    }
 
    // Transmit or reflect depending on the transmission probability
    const G4double x = Random::shoot();
 
    if(x <= transmissionProbability) { // Transmission
      DEBUG("Particle " << theParticle->getID() << " passes the Coulomb barrier, transmitting." << std::endl);
      return new TransmissionChannel(theNucleus, theParticle);
    } else { // Reflection
      DEBUG("Particle " << theParticle->getID() << " does not pass the Coulomb barrier, reflection." << std::endl);
      return new ReflectionChannel(theNucleus, theParticle);
    }
  }

Referenced by getFinalState().

getFinalState()

G4INCL::FinalState * G4INCL::SurfaceAvatar::getFinalState

(

)

const

Definition at line 148 of file G4INCLSurfaceAvatar.cc.

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

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

)

const

Calculate the transmission probability for the particle.

Definition at line 184 of file G4INCLSurfaceAvatar.cc.

                                                                                          {
 
    G4double E = particle->getKineticEnergy();
    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();
    E += particle->getEmissionQValueCorrection(theA, theZ);
 
    if (E <= V) // No transmission if total energy < 0
      return 0.0;
 
    const G4double m = particle->getMass();
    const G4double EMinusV = E-V;
    const G4double EMinusV2 = EMinusV*EMinusV;
 
    // Intermediate variable for calculation
    const G4double x=std::sqrt((2.*m*E+E*E)*(2.*m*EMinusV+EMinusV2));
 
    // The transmission probability for a potential step
    G4double theTransmissionProbability =
      4.*x/(2.*m*(E+EMinusV)+E*E+(EMinusV2)+2.*x);
 
    // For neutral and negative particles, no Coulomb transmission
    // Also, no Coulomb if the particle takes away all of the nuclear charge
    const G4int theParticleZ = particle->getZ();
    if (theParticleZ <= 0 || theParticleZ >= theZ)
      return theTransmissionProbability;
 
    // Nominal Coulomb barrier
    const G4double theTransmissionBarrier = theNucleus->getTransmissionBarrier(particle);
    if (EMinusV >= theTransmissionBarrier) // Above the Coulomb barrier
      return theTransmissionProbability;
 
    // Coulomb-penetration factor
    const G4double px = std::sqrt(EMinusV/theTransmissionBarrier);
    const G4double logCoulombTransmission =
      theParticleZ*(theZ-theParticleZ)/137.03*std::sqrt(2.*m/EMinusV/(1.+EMinusV/2./m))
      *(std::acos(px)-px*std::sqrt(1.-px*px));
    if (logCoulombTransmission > 35.) // Transmission is forbidden by Coulomb
      return 0.;
    theTransmissionProbability *= std::exp(-2.*logCoulombTransmission);
 
    return theTransmissionProbability;
  }

Referenced by getChannel().

postInteraction()

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

virtual

Implements G4INCL::IAvatar.

Definition at line 155 of file G4INCLSurfaceAvatar.cc.

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

preInteraction()

void G4INCL::SurfaceAvatar::preInteraction ( )

virtual

Implements G4INCL::IAvatar.

Definition at line 153 of file G4INCLSurfaceAvatar.cc.

{}

---

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

• G4INCLSurfaceAvatar.hh
• G4INCLSurfaceAvatar.cc