G4INCL::ProjectileRemnant Class Reference

#include <G4INCLProjectileRemnant.hh>

Inheritance diagram for G4INCL::ProjectileRemnant:

Public Member Functions
	ProjectileRemnant (ParticleSpecies const species, const G4double kineticEnergy)
	~ProjectileRemnant ()
void	reset ()
	Reset the projectile remnant to the state at the beginning of the cascade.
void	removeParticle (Particle *const p, const G4double theProjectileCorrection)
	Remove a nucleon from the projectile remnant.
ParticleList	addDynamicalSpectators (ParticleList pL)
	Add back dynamical spectators to the projectile remnant.
ParticleList	addMostDynamicalSpectators (ParticleList pL)
	Add back dynamical spectators to the projectile remnant.
void	deleteStoredComponents ()
	Clear the stored projectile components and delete the particles.
void	clearStoredComponents ()
	Clear the stored projectile components.
void	clearEnergyLevels ()
	Clear the stored energy levels.
G4double	computeExcitationEnergy (const long exceptID) const
	Compute the excitation energy.
EnergyLevels	getPresentEnergyLevels (const long exceptID) const
void	storeComponents ()
	Store the projectile components.
G4int	getNumberStoredComponents () const
	Get the number of the stored components.
void	storeEnergyLevels ()
	Store the energy levels.

---

Detailed Description

Definition at line 59 of file G4INCLProjectileRemnant.hh.

---

Constructor & Destructor Documentation

G4INCL::ProjectileRemnant::ProjectileRemnant	(	ParticleSpecies const	species,
		const G4double	kineticEnergy
	)			[inline]

Definition at line 65 of file G4INCLProjectileRemnant.hh.

References G4INCL::Cluster::boost(), G4INCL::Cluster::freezeInternalMotion(), G4INCL::Particle::getMass(), G4INCL::Cluster::initializeParticles(), G4INCL::Cluster::internalBoostToCM(), G4INCL::Cluster::makeProjectileSpectator(), G4INCL::Cluster::putParticlesOffShell(), G4INCL::Particle::setTableMass(), and storeEnergyLevels().

      : Cluster(species.theZ, species.theA) {

      // Use the table mass
      setTableMass();

      // Set the kinematics
      const G4double projectileMass = getMass();
      const G4double energy = kineticEnergy + projectileMass;
      const G4double momentumZ = std::sqrt(energy*energy - projectileMass*projectileMass);

      // Initialise the particles
      initializeParticles();
      internalBoostToCM();
      putParticlesOffShell();

      // Store the energy levels of the ProjectileRemnant (used to compute its
      // excitation energy)
      storeEnergyLevels();

      // Boost the whole thing
      const ThreeVector aBoostVector = ThreeVector(0.0, 0.0, momentumZ / energy);
      boost(-aBoostVector);

      // Freeze the internal motion of the particles
      freezeInternalMotion();

      // Set as projectile spectator
      makeProjectileSpectator();
    }

G4INCL::ProjectileRemnant::~ProjectileRemnant

(

)

[inline]

Definition at line 96 of file G4INCLProjectileRemnant.hh.

References clearEnergyLevels(), and deleteStoredComponents().

                         {
      deleteStoredComponents();
      clearEnergyLevels();
    }

---

Member Function Documentation

ParticleList G4INCL::ProjectileRemnant::addDynamicalSpectators

(

ParticleList

pL

)

Add back dynamical spectators to the projectile remnant.

Try to add the dynamical spectators back to the projectile remnant. Refuse to do so if this leads to a negative projectile excitation energy.

Return a list of rejected dynamical spectators.

Definition at line 123 of file G4INCLProjectileRemnant.cc.

                                                                        {
    // Try as hard as possible to add back all the dynamical spectators.
    // Don't add spectators that lead to negative excitation energies, but
    // iterate over the spectators as many times as possible, until
    // absolutely sure that all of them were rejected.
    unsigned int accepted;
    do {
      accepted = 0;
      ParticleList toBeAdded = pL;
      for(ParticleIter p=toBeAdded.begin(); p!=toBeAdded.end(); ++p) {
        G4bool isAccepted = addDynamicalSpectator(*p);
        if(isAccepted) {
          pL.remove(*p);
          accepted++;
        }
      }
    } while(accepted > 0);
    return pL;
  }

ParticleList G4INCL::ProjectileRemnant::addMostDynamicalSpectators

(

ParticleList

pL

)

Add back dynamical spectators to the projectile remnant.

Try as hard as possible to add back all the dynamical spectators. Don't add spectators that lead to negative excitation energies. Start by adding all of them, and repeatedly remove the most troublesome one until the excitation energy becomes non-negative.

Return a list of rejected dynamical spectators.

Definition at line 143 of file G4INCLProjectileRemnant.cc.

References G4INCL::ParticleTable::getTableMass, G4INCL::ThreeVector::getZ(), G4INCL::ThreeVector::mag2(), G4INCL::Cluster::particles, G4INCL::Particle::theA, G4INCL::Particle::theEnergy, G4INCL::Particle::theMomentum, and G4INCL::Particle::theZ.

                                                                            {
    // Try as hard as possible to add back all the dynamical spectators.
    // Don't add spectators that lead to negative excitation energies. Start by
    // adding all of them, and repeatedly remove the most troublesome one until
    // the excitation energy becomes non-negative.

    // Put all the spectators in the projectile
    ThreeVector theNewMomentum = theMomentum;
    G4double theNewEnergy = theEnergy;
    G4int theNewA = theA;
    G4int theNewZ = theZ;
    for(ParticleIter p=pL.begin(); p!=pL.end(); ++p) {
// assert((*p)->isNucleon());
      // Add the initial (off-shell) momentum and energy to the projectile remnant
      theNewMomentum += getStoredMomentum(*p);
      theNewEnergy += (*p)->getEnergy();
      theNewA += (*p)->getA();
      theNewZ += (*p)->getZ();
    }

    // Check that the excitation energy of the new projectile remnant is non-negative
    const G4double theNewMass = ParticleTable::getTableMass(theNewA,theNewZ);
    const G4double theNewInvariantMassSquared = theNewEnergy*theNewEnergy-theNewMomentum.mag2();

    G4bool positiveExcitationEnergy = false;
    if(theNewInvariantMassSquared>=0.) {
      const G4double theNewInvariantMass = std::sqrt(theNewInvariantMassSquared);
      positiveExcitationEnergy = (theNewInvariantMass-theNewMass>-1.e-5);
    }

    // Keep removing nucleons from the projectile remnant until we achieve a
    // non-negative excitation energy.
    ParticleList rejected;
    while(!positiveExcitationEnergy && !pL.empty()) {
      G4double maxExcitationEnergy = -1.E30;
      ParticleList::iterator best = pL.end();
      ThreeVector bestMomentum;
      G4double bestEnergy = -1.;
      G4int bestA = -1, bestZ = -1;
      for(ParticleList::iterator p=pL.begin(); p!=pL.end(); ++p) {
        // Subtract the initial (off-shell) momentum and energy from the new
        // projectile remnant
        const ThreeVector theNewerMomentum = theNewMomentum - getStoredMomentum(*p);
        const G4double theNewerEnergy = theNewEnergy - (*p)->getEnergy();
        const G4int theNewerA = theNewA - (*p)->getA();
        const G4int theNewerZ = theNewZ - (*p)->getZ();

        const G4double theNewerMass = ParticleTable::getTableMass(theNewerA,theNewerZ);
        const G4double theNewerInvariantMassSquared = theNewerEnergy*theNewerEnergy-theNewerMomentum.mag2();

        if(theNewerInvariantMassSquared>=-1.e-5) {
          const G4double theNewerInvariantMass = std::sqrt(std::max(0.,theNewerInvariantMassSquared));
          const G4double theNewerExcitationEnergy = theNewerInvariantMass-theNewerMass;
          // Pick the nucleon that maximises the excitation energy of the
          // ProjectileRemnant
          if(theNewerExcitationEnergy>maxExcitationEnergy) {
            best = p;
            maxExcitationEnergy = theNewerExcitationEnergy;
            bestMomentum = theNewerMomentum;
            bestEnergy = theNewerEnergy;
            bestA = theNewerA;
            bestZ = theNewerZ;
          }
        }
      }

      // If we couldn't even calculate the excitation energy, fail miserably
      if(best==pL.end())
        return pL;

      rejected.push_back(*best);
      pL.erase(best);
      theNewMomentum = bestMomentum;
      theNewEnergy = bestEnergy;
      theNewA = bestA;
      theNewZ = bestZ;

      if(maxExcitationEnergy>0.) {
        // Stop here
        positiveExcitationEnergy = true;
      }
    }

    // Add the accepted participants to the projectile remnant
    for(ParticleIter p=pL.begin(); p!=pL.end(); ++p) {
      particles.push_back(*p);
    }
    theA = theNewA;
    theZ = theNewZ;
    theMomentum = theNewMomentum;
    theEnergy = theNewEnergy;

    return rejected;
  }

void G4INCL::ProjectileRemnant::clearEnergyLevels

(

)

[inline]

Clear the stored energy levels.

Definition at line 145 of file G4INCLProjectileRemnant.hh.

Referenced by ~ProjectileRemnant().

                             {
      theInitialEnergyLevels.clear();
      theGroundStateEnergies.clear();
    }

void G4INCL::ProjectileRemnant::clearStoredComponents

(

)

[inline]

Clear the stored projectile components.

Definition at line 140 of file G4INCLProjectileRemnant.hh.

Referenced by deleteStoredComponents().

                                 {
      storedComponents.clear();
    }

G4double G4INCL::ProjectileRemnant::computeExcitationEnergy

(

const long

exceptID

)

const

Compute the excitation energy.

Compute the excitation energy of the projectile-like remnant as the difference between the initial and the present configuration. This follows the algorithm proposed by A. Boudard in INCL4.2-HI, as implemented in Geant4.

Returns:

the excitation energy

Definition at line 268 of file G4INCLProjectileRemnant.cc.

References getPresentEnergyLevels(), and G4INCL::Particle::theA.

Referenced by G4INCL::ParticleEntryChannel::getFinalState().

                                                                               {
    // The ground-state energy is the sum of the A smallest initial projectile
    // energies.
    // For the last nucleon, return 0 so that the algorithm will just put it on
    // shell.
    if(theA==1)
      return 0.;

    const G4double groundState = theGroundStateEnergies.at(theA-2);

    // Compute the sum of the presently occupied energy levels
    const EnergyLevels theEnergyLevels = getPresentEnergyLevels(exceptID);
    const G4double excitedState = std::accumulate(
        theEnergyLevels.begin(),
        theEnergyLevels.end(),
        0.);

    return excitedState-groundState;
  }

void G4INCL::ProjectileRemnant::deleteStoredComponents

(

)

[inline]

Clear the stored projectile components and delete the particles.

Definition at line 133 of file G4INCLProjectileRemnant.hh.

References clearStoredComponents().

Referenced by ~ProjectileRemnant().

                                  {
      for(std::map<long,Particle*>::const_iterator p=storedComponents.begin(); p!=storedComponents.end(); ++p)
        delete p->second;
      clearStoredComponents();
    }

G4int G4INCL::ProjectileRemnant::getNumberStoredComponents

(

)

const [inline]

Get the number of the stored components.

Definition at line 183 of file G4INCLProjectileRemnant.hh.

Referenced by G4INCL::Nucleus::finalizeProjectileRemnant().

                                            {
      return storedComponents.size();
    }

EnergyLevels G4INCL::ProjectileRemnant::getPresentEnergyLevels

(

const long

exceptID

)

const [inline]

Definition at line 161 of file G4INCLProjectileRemnant.hh.

References G4INCL::Cluster::particles.

Referenced by computeExcitationEnergy().

                                                                   {
      EnergyLevels theEnergyLevels;
      for(ParticleIter p=particles.begin(); p!=particles.end(); ++p) {
        if((*p)->getID()!=exceptID) {
          EnergyLevelMap::const_iterator i = theInitialEnergyLevels.find((*p)->getID());
// assert(i!=theInitialEnergyLevels.end());
          theEnergyLevels.push_back(i->second);
        }
      }
// assert(theEnergyLevels.size()==particles.size()-1);
      return theEnergyLevels;
    }

void G4INCL::ProjectileRemnant::removeParticle	(	Particle *const	p,
		const G4double	theProjectileCorrection
	)

Remove a nucleon from the projectile remnant.

Parameters:

	p	particle to be removed
	theProjectileCorrection	correction to be given to the projectile total energy

Definition at line 78 of file G4INCLProjectileRemnant.cc.

References DEBUG, G4INCL::Particle::getA(), G4INCL::Particle::getEnergy(), G4INCL::Particle::getMomentum(), G4INCL::Particle::getZ(), G4INCL::Cluster::particles, G4INCL::Cluster::print(), G4INCL::Particle::print(), G4INCL::Cluster::removeParticle(), G4INCL::Particle::theA, G4INCL::Particle::theEnergy, G4INCL::Particle::theMomentum, and G4INCL::Particle::theZ.

Referenced by G4INCL::ParticleEntryChannel::getFinalState().

                                                                                                   {
// assert(p->isNucleon());

    DEBUG("The following Particle is about to be removed from the ProjectileRemnant:"
        << std::endl << p->print()
        << "theProjectileCorrection=" << theProjectileCorrection << std::endl);
    // Update A, Z, momentum and energy of the projectile remnant
    theA -= p->getA();
    theZ -= p->getZ();

    ThreeVector const &oldMomentum = p->getMomentum();
    const G4double oldEnergy = p->getEnergy();
    Cluster::removeParticle(p);

#if !defined(NDEBUG) && !defined(INCLXX_IN_GEANT4_MODE)
    ThreeVector theTotalMomentum;
    G4double theTotalEnergy = 0.;
    const G4double theThreshold = 0.1;
#endif

    if(getA()>0) { // if there are any particles left
// assert((unsigned int)getA()==particles.size());

      const G4double theProjectileCorrectionPerNucleon = theProjectileCorrection / particles.size();

      // Update the kinematics of the components
      for(ParticleIter i=particles.begin(); i!=particles.end(); ++i) {
        (*i)->setEnergy((*i)->getEnergy() + theProjectileCorrectionPerNucleon);
        (*i)->setMass((*i)->getInvariantMass());
#if !defined(NDEBUG) && !defined(INCLXX_IN_GEANT4_MODE)
        theTotalMomentum += (*i)->getMomentum();
        theTotalEnergy += (*i)->getEnergy();
#endif
      }
    }

    theMomentum -= oldMomentum;
    theEnergy -= oldEnergy - theProjectileCorrection;

// assert(std::abs((theTotalMomentum-theMomentum).mag())<theThreshold);
// assert(std::abs(theTotalEnergy-theEnergy)<theThreshold);
    DEBUG("After Particle removal, the ProjectileRemnant looks like this:"
        << std::endl << print());
  }

void G4INCL::ProjectileRemnant::reset

(

)

Reset the projectile remnant to the state at the beginning of the cascade.

Definition at line 54 of file G4INCLProjectileRemnant.cc.

References G4INCL::Cluster::addParticle(), DEBUG, G4INCL::Cluster::deleteParticles(), G4INCL::Particle::nCollisions, G4INCL::Particle::Particle(), G4INCL::Cluster::print(), G4INCL::Particle::setTableMass(), G4INCL::Particle::theA, G4INCL::Particle::theEnergy, G4INCL::Particle::theMomentum, G4INCL::Particle::thePosition, G4INCL::Particle::thePotentialEnergy, and G4INCL::Particle::theZ.

                                {
    deleteParticles();
    thePosition = ThreeVector();
    theMomentum = ThreeVector();
    theEnergy = 0.0;
    thePotentialEnergy = 0.0;
    theA = 0;
    theZ = 0;
    nCollisions = 0;

    for(std::map<long, Particle*>::const_iterator i=storedComponents.begin(); i!=storedComponents.end(); ++i) {
      Particle *p = new Particle(*(i->second));
      EnergyLevelMap::iterator energyIter = theInitialEnergyLevels.find(i->first);
// assert(energyIter!=theInitialEnergyLevels.end());
      const G4double energyLevel = energyIter->second;
      theInitialEnergyLevels.erase(energyIter);
      theInitialEnergyLevels[p->getID()] = energyLevel;
      addParticle(p);
    }
    thePosition /= theA;
    setTableMass();
    DEBUG("ProjectileRemnant object was reset:" << std::endl << print());
  }

void G4INCL::ProjectileRemnant::storeComponents

(

)

[inline]

Store the projectile components.

Definition at line 175 of file G4INCLProjectileRemnant.hh.

References G4INCL::Particle::Particle(), and G4INCL::Cluster::particles.

                           {
      for(ParticleIter p=particles.begin(); p!=particles.end(); ++p) {
        // Store the particles (needed for forced CN)
        storedComponents[(*p)->getID()]=new Particle(**p);
      }
    }

void G4INCL::ProjectileRemnant::storeEnergyLevels

(

)

[inline]

Store the energy levels.

Definition at line 188 of file G4INCLProjectileRemnant.hh.

References G4INCL::Cluster::particles.

Referenced by ProjectileRemnant().

                             {
      EnergyLevels energies;

      for(ParticleIter p=particles.begin(); p!=particles.end(); ++p) {
        const G4double theCMEnergy = (*p)->getEnergy();
        // Store the CM energy in the EnergyLevels map
        theInitialEnergyLevels[(*p)->getID()] = theCMEnergy;
        energies.push_back(theCMEnergy);
      }

      std::sort(energies.begin(), energies.end());
// assert(energies.size()==(unsigned int)theA);
      theGroundStateEnergies.resize(energies.size());
      // Compute the partial sums of the CM energies -- they are our reference
      // ground-state energies for any number of nucleons
      std::partial_sum(energies.begin(), energies.end(), theGroundStateEnergies.begin());
    }

---

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

• G4INCLProjectileRemnant.hh
• G4INCLProjectileRemnant.cc

---