G4INCL::ParticleEntryChannel Class Reference

#include <G4INCLParticleEntryChannel.hh>

Inheritance diagram for G4INCL::ParticleEntryChannel:

Public Member Functions
void	fillFinalState (FinalState *fs)
FinalState *	getFinalState ()
	ParticleEntryChannel (Nucleus *n, Particle *p)
virtual	~ParticleEntryChannel ()

Private Member Functions
G4bool	particleEnters (const G4double theQValueCorrection)
	Modify particle that enters the nucleus. More...

Private Attributes
Nucleus *	theNucleus
Particle *	theParticle

Detailed Description

Definition at line 49 of file G4INCLParticleEntryChannel.hh.

Constructor & Destructor Documentation

ParticleEntryChannel()

G4INCL::ParticleEntryChannel::ParticleEntryChannel	(	Nucleus *	n,
		Particle *	p
	)

Definition at line 45 of file G4INCLParticleEntryChannel.cc.

    :theNucleus(n), theParticle(p)
  {}

~ParticleEntryChannel()

G4INCL::ParticleEntryChannel::~ParticleEntryChannel ( )

virtual

Definition at line 49 of file G4INCLParticleEntryChannel.cc.

  {}

Member Function Documentation

fillFinalState()

void G4INCL::ParticleEntryChannel::fillFinalState ( FinalState *  fs )

virtual

Implements G4INCL::IChannel.

Definition at line 52 of file G4INCLParticleEntryChannel.cc.

                                                          {
    // Behaves slightly differency if a third body (the projectile) is present
    G4bool isNN = theNucleus->isNucleusNucleusCollision();
 
    /* Corrections to the energy of the entering particle
     *
     * In particle-nucleus reactions, the goal of this correction is to satisfy
     * energy conservation in particle-nucleus reactions using real particle
     * and nuclear masses.
     *
     * In nucleus-nucleus reactions, in addition to the above, the correction
     * is determined by a model for the excitation energy of the
     * quasi-projectile (QP). The energy of the entering nucleon is such that
     * the QP excitation energy, as determined by conservation, is what given
     * by our model.
     *
     * Possible choices for the correction (or, equivalently, for the QP
     * excitation energy):
     *
     * 1. the correction is 0. (same as in particle-nucleus);
     * 2. the correction is the separation energy of the entering nucleon in
     *    the current QP;
     * 3. the QP excitation energy is given by A. Boudard's algorithm, as
     *    implemented in INCL4.2-HI/Geant4.
     * 4. the QP excitation energy vanishes.
     *
     * Ideally, the QP excitation energy should always be >=0. Algorithms 1.
     * and 2. do not guarantee this, although violations to the rule seem to be
     * more severe for 1. than for 2.. Algorithms 3. and 4., by construction,
     * yields non-negative QP excitation energies.
     */
    G4double theCorrection;
    if(isNN) {
// assert(theParticle->isNucleonorLambda()); // Possible hypernucleus projectile of inverse kinematic
      ProjectileRemnant * const projectileRemnant = theNucleus->getProjectileRemnant();
// assert(projectileRemnant);
 
      // No correction (model 1. above)
      /*
      theCorrection = theParticle->getEmissionQValueCorrection(
          theNucleus->getA() + theParticle->getA(),
          theNucleus->getZ() + theParticle->getZ())
        + theParticle->getTableMass() - theParticle->getINCLMass();
      const G4double theProjectileCorrection = 0.;
      */
 
      // Correct the energy of the entering particle for the Q-value of the
      // emission from the projectile (model 2. above)
      /*
      theCorrection = theParticle->getTransferQValueCorrection(
          projectileRemnant->getA(), projectileRemnant->getZ(),
          theNucleus->getA(), theNucleus->getZ());
      G4double theProjectileCorrection;
      if(projectileRemnant->getA()>theParticle->getA()) { // if there are any particles left
        // Compute the projectile Q-value (to be used as a correction to the
        // other components of the projectile remnant)
        theProjectileCorrection = ParticleTable::getTableQValue(
            projectileRemnant->getA() - theParticle->getA(),
            projectileRemnant->getZ() - theParticle->getZ(),
            theParticle->getA(),
            theParticle->getZ());
      } else
        theProjectileCorrection = 0.;
      */
 
      // Fix the correction in such a way that the quasi-projectile excitation
      // energy is given by A. Boudard's INCL4.2-HI model (model 3. above).
      const G4double theProjectileExcitationEnergy =
        (projectileRemnant->getA()-theParticle->getA()>1) ?
        (projectileRemnant->computeExcitationEnergyExcept(theParticle->getID())) :
        0.;
      // Set the projectile excitation energy to zero (cold quasi-projectile,
      // model 4. above).
      // const G4double theProjectileExcitationEnergy = 0.;
      // The part that follows is common to model 3. and 4.
      const G4double theProjectileEffectiveMass =
        ParticleTable::getTableMass(projectileRemnant->getA() - theParticle->getA(), projectileRemnant->getZ() - theParticle->getZ(), projectileRemnant->getS() - theParticle->getS())
        + theProjectileExcitationEnergy;
      const ThreeVector &theProjectileMomentum = projectileRemnant->getMomentum() - theParticle->getMomentum();
      const G4double theProjectileEnergy = std::sqrt(theProjectileMomentum.mag2() + theProjectileEffectiveMass*theProjectileEffectiveMass);
      const G4double theProjectileCorrection = theProjectileEnergy - (projectileRemnant->getEnergy() - theParticle->getEnergy());
      theCorrection = theParticle->getEmissionQValueCorrection(
          theNucleus->getA() + theParticle->getA(),
          theNucleus->getZ() + theParticle->getZ(),
          theNucleus->getS() + theParticle->getS())
        + theParticle->getTableMass() - theParticle->getINCLMass()
        + theProjectileCorrection;
      // end of part common to model 3. and 4.
 
 
      projectileRemnant->removeParticle(theParticle, theProjectileCorrection);
    } else {
      const G4int ACN = theNucleus->getA() + theParticle->getA();
      const G4int ZCN = theNucleus->getZ() + theParticle->getZ();
      const G4int SCN = theNucleus->getS() + theParticle->getS();
      // Correction to the Q-value of the entering particle
      if(theParticle->isKaon()) theCorrection = theParticle->getEmissionQValueCorrection(ACN,ZCN,theNucleus->getS());
      else theCorrection = theParticle->getEmissionQValueCorrection(ACN,ZCN,SCN);
      INCL_DEBUG("The following Particle enters with correction " << theCorrection << '\n'
          << theParticle->print() << '\n');
    }
 
    const G4double energyBefore = theParticle->getEnergy() - theCorrection;
    G4bool success = particleEnters(theCorrection);
    fs->addEnteringParticle(theParticle);
 
    if(!success) {
      fs->makeParticleBelowZero();
    } else if(theParticle->isNucleonorLambda() &&
        theParticle->getKineticEnergy()<theNucleus->getPotential()->getFermiEnergy(theParticle)) {
      // If the participant is a nucleon entering below its Fermi energy, force a
      // compound nucleus
      fs->makeParticleBelowFermi();
    } else if(theParticle->isKaon()) theNucleus->setNumberOfKaon(theNucleus->getNumberOfKaon()+1);
 
    fs->setTotalEnergyBeforeInteraction(energyBefore);
  }

References G4INCL::FinalState::addEnteringParticle(), G4INCL::ProjectileRemnant::computeExcitationEnergyExcept(), G4INCL::Particle::getA(), G4INCL::Particle::getEmissionQValueCorrection(), G4INCL::Particle::getEnergy(), G4INCL::NuclearPotential::INuclearPotential::getFermiEnergy(), G4INCL::Particle::getID(), G4INCL::Particle::getINCLMass(), G4INCL::Particle::getKineticEnergy(), G4INCL::Particle::getMomentum(), G4INCL::Particle::getNumberOfKaon(), G4INCL::Nucleus::getPotential(), G4INCL::Nucleus::getProjectileRemnant(), G4INCL::Particle::getS(), G4INCL::Particle::getTableMass(), G4INCL::ParticleTable::getTableMass, G4INCL::Particle::getZ(), INCL_DEBUG, G4INCL::Particle::isKaon(), G4INCL::Particle::isNucleonorLambda(), G4INCL::Nucleus::isNucleusNucleusCollision(), G4INCL::ThreeVector::mag2(), G4INCL::FinalState::makeParticleBelowFermi(), G4INCL::FinalState::makeParticleBelowZero(), particleEnters(), G4INCL::Particle::print(), G4INCL::ProjectileRemnant::removeParticle(), G4INCL::Particle::setNumberOfKaon(), G4INCL::FinalState::setTotalEnergyBeforeInteraction(), theNucleus, and theParticle.

getFinalState()

FinalState * G4INCL::IChannel::getFinalState ( )

inherited

Definition at line 50 of file G4INCLIChannel.cc.

                                      {
    FinalState *fs = new FinalState;
    fillFinalState(fs);
    return fs;
  }

References G4INCL::IChannel::fillFinalState().

particleEnters()

G4bool G4INCL::ParticleEntryChannel::particleEnters ( const G4double  theQValueCorrection )

private

Modify particle that enters the nucleus.

Modify the particle momentum and/or position when the particle enters the nucleus.

Returns

false if the particle enters below 0 total energy.

Definition at line 170 of file G4INCLParticleEntryChannel.cc.

                                                                                {
 
    // \todo{this is the place to add refraction}
 
    theParticle->setINCLMass(); // Will automatically put the particle on shell
 
    // Add the nuclear potential to the kinetic energy when entering the
    // nucleus
 
    class IncomingEFunctor : public RootFunctor {
      public:
        IncomingEFunctor(Particle * const p, Nucleus const * const n, const G4double correction) :
          RootFunctor(0., 1E6),
          theParticle(p),
          thePotential(n->getPotential()),
          theEnergy(theParticle->getEnergy()),
          theMass(theParticle->getMass()),
          theQValueCorrection(correction),
          refraction(n->getStore()->getConfig()->getRefraction()),
          theMomentumDirection(theParticle->getMomentum())
          {
            if(refraction) {
              const ThreeVector &position = theParticle->getPosition();
              const G4double r2 = position.mag2();
              if(r2>0.)
                normal = - position / std::sqrt(r2);
              G4double cosIncidenceAngle = theParticle->getCosRPAngle();
              if(cosIncidenceAngle < -1.)
                sinIncidenceAnglePOut = 0.;
              else
                sinIncidenceAnglePOut = theMomentumDirection.mag()*std::sqrt(1.-cosIncidenceAngle*cosIncidenceAngle);
            } else {
              sinIncidenceAnglePOut = 0.;
            }
          }
        ~IncomingEFunctor() {}
        G4double operator()(const G4double v) const {
          G4double energyInside = std::max(theMass, theEnergy + v - theQValueCorrection);
          theParticle->setEnergy(energyInside);
          theParticle->setPotentialEnergy(v);
          if(refraction) {
            // Compute the new direction of the particle momentum
            const G4double pIn = std::sqrt(energyInside*energyInside-theMass*theMass);
            const G4double sinRefractionAngle = sinIncidenceAnglePOut/pIn;
            const G4double cosRefractionAngle = (sinRefractionAngle>1.) ? 0. : std::sqrt(1.-sinRefractionAngle*sinRefractionAngle);
            const ThreeVector momentumInside = theMomentumDirection - normal * normal.dot(theMomentumDirection) + normal * (pIn * cosRefractionAngle);
            theParticle->setMomentum(momentumInside);
          } else {
            theParticle->setMomentum(theMomentumDirection); // keep the same direction
          }
          // Scale the particle momentum
          theParticle->adjustMomentumFromEnergy();
          return v - thePotential->computePotentialEnergy(theParticle);
        }
        void cleanUp(const G4bool /*success*/) const {}
      private:
        Particle *theParticle;
        NuclearPotential::INuclearPotential const *thePotential;
        const G4double theEnergy;
        const G4double theMass;
        const G4double theQValueCorrection;
        const G4bool refraction;
        const ThreeVector theMomentumDirection;
        ThreeVector normal;
        G4double sinIncidenceAnglePOut;
    } theIncomingEFunctor(theParticle,theNucleus,theQValueCorrection);
 
    G4double v = theNucleus->getPotential()->computePotentialEnergy(theParticle);
    if(theParticle->getKineticEnergy()+v-theQValueCorrection<0.) { // Particle entering below 0. Die gracefully
      INCL_DEBUG("Particle " << theParticle->getID() << " is trying to enter below 0" << '\n');
      return false;
    }
    const RootFinder::Solution theSolution = RootFinder::solve(&theIncomingEFunctor, v);
    if(theSolution.success) { // Apply the solution
      theIncomingEFunctor(theSolution.x);
      INCL_DEBUG("Particle successfully entered:\n" << theParticle->print() << '\n');
    } else {
      INCL_WARN("Couldn't compute the potential for incoming particle, root-finding algorithm failed." << '\n');
    }
    return theSolution.success;
  }

References G4INCL::Particle::adjustMomentumFromEnergy(), G4INCL::NuclearPotential::INuclearPotential::computePotentialEnergy(), G4INCL::Particle::getCosRPAngle(), G4INCL::Particle::getEnergy(), G4INCL::Particle::getID(), G4INCL::Particle::getKineticEnergy(), G4INCL::Particle::getMass(), G4INCL::Particle::getMomentum(), G4INCL::Particle::getPosition(), G4INCL::Nucleus::getPotential(), INCL_DEBUG, INCL_WARN, G4INCL::Math::max(), CLHEP::detail::n, CLHEP::normal(), G4INCL::Particle::print(), G4INCL::Particle::setEnergy(), G4INCL::Particle::setINCLMass(), G4INCL::Particle::setMomentum(), G4INCL::Particle::setPotentialEnergy(), G4INCL::RootFinder::solve(), G4INCL::RootFinder::Solution::success, theNucleus, theParticle, and G4INCL::RootFinder::Solution::x.

Referenced by fillFinalState().

Field Documentation

theNucleus

Nucleus* G4INCL::ParticleEntryChannel::theNucleus

private

Definition at line 66 of file G4INCLParticleEntryChannel.hh.

Referenced by fillFinalState(), and particleEnters().

theParticle

Particle* G4INCL::ParticleEntryChannel::theParticle

private

Definition at line 67 of file G4INCLParticleEntryChannel.hh.

Referenced by fillFinalState(), and particleEnters().

---

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

• source/processes/hadronic/models/inclxx/incl_physics/include/G4INCLParticleEntryChannel.hh
• source/processes/hadronic/models/inclxx/incl_physics/src/G4INCLParticleEntryChannel.cc