#include <G4INCLProjectileRemnant.hh>

Inheritance diagram for G4INCL::ProjectileRemnant:

Public Types
typedef std::vector< G4double >	EnergyLevels

typedef std::map< long, G4double >	EnergyLevelMap

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. More...

void	removeParticle (Particle *const p, const G4double theProjectileCorrection)
	Remove a nucleon from the projectile remnant. More...

ParticleList	addDynamicalSpectators (ParticleList pL)
	Add back dynamical spectators to the projectile remnant. More...

ParticleList	addMostDynamicalSpectators (ParticleList pL)
	Add back dynamical spectators to the projectile remnant. More...

ParticleList	addAllDynamicalSpectators (ParticleList pL)
	Add back all dynamical spectators to the projectile remnant. More...

void	deleteStoredComponents ()
	Clear the stored projectile components and delete the particles. More...

void	clearStoredComponents ()
	Clear the stored projectile components. More...

void	clearEnergyLevels ()
	Clear the stored energy levels. More...

G4double	computeExcitationEnergyExcept (const long exceptID) const
	Compute the excitation energy when a nucleon is removed. More...

G4double	computeExcitationEnergyWith (const ParticleList &pL) const
	Compute the excitation energy if some nucleons are put back. More...

void	storeComponents ()
	Store the projectile components. More...

G4int	getNumberStoredComponents () const
	Get the number of the stored components. More...

void	storeEnergyLevels ()
	Store the energy levels. More...

EnergyLevels const &	getGroundStateEnergies () const

Public Member Functions inherited from G4INCL::Cluster
	Cluster (const G4int Z, const G4int A, const G4bool createParticleSampler=true)
	Standard Cluster constructor. More...

template<class Iterator >
	Cluster (Iterator begin, Iterator end)

virtual	~Cluster ()

	Cluster (const Cluster &rhs)
	Copy constructor. More...

Cluster &	operator= (const Cluster &rhs)
	Assignment operator. More...

void	swap (Cluster &rhs)
	Helper method for the assignment operator. More...

ParticleSpecies	getSpecies () const
	Get the particle species. More...

void	deleteParticles ()

void	clearParticles ()

void	setZ (const G4int Z)
	Set the charge number of the cluster. More...

void	setA (const G4int A)
	Set the mass number of the cluster. More...

G4double	getExcitationEnergy () const
	Get the excitation energy of the cluster. More...

void	setExcitationEnergy (const G4double e)
	Set the excitation energy of the cluster. More...

virtual G4double	getTableMass () const
	Get the real particle mass. More...

ParticleList const &	getParticles () const

void	removeParticle (Particle *const p)
	Remove a particle from the cluster components. More...

void	addParticle (Particle *const p)

void	addParticles (ParticleList const &pL)
	Add a list of particles to the cluster. More...

ParticleList	getParticleList () const
	Returns the list of particles that make up the cluster. More...

std::string	print () const

virtual void	initializeParticles ()
	Initialise the NuclearDensity pointer and sample the particles. More...

void	internalBoostToCM ()
	Boost to the CM of the component particles. More...

void	putParticlesOffShell ()
	Put the cluster components off shell. More...

void	setPosition (const ThreeVector &position)
	Set the position of the cluster. More...

void	boost (const ThreeVector &aBoostVector)
	Boost the cluster with the indicated velocity. More...

void	freezeInternalMotion ()
	Freeze the internal motion of the particles. More...

virtual void	rotate (const G4double angle, const ThreeVector &axis)
	Rotate position and momentum of all the particles. More...

virtual void	makeProjectileSpectator ()
	Make all the components projectile spectators, too. More...

virtual void	makeTargetSpectator ()
	Make all the components target spectators, too. More...

virtual void	makeParticipant ()
	Make all the components participants, too. More...

ThreeVector const &	getSpin () const
	Get the spin of the nucleus. More...

void	setSpin (const ThreeVector &j)
	Set the spin of the nucleus. More...

G4INCL::ThreeVector	getAngularMomentum () const
	Get the total angular momentum (orbital + spin) More...

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

	Particle (ParticleType t, G4double energy, ThreeVector const &momentum, ThreeVector const &position)

	Particle (ParticleType t, ThreeVector const &momentum, ThreeVector const &position)

virtual	~Particle ()

	Particle (const Particle &rhs)
	Copy constructor. More...

Particle &	operator= (const Particle &rhs)
	Assignment operator. More...

G4INCL::ParticleType	getType () const

void	setType (ParticleType t)

G4bool	isNucleon () const

ParticipantType	getParticipantType () const

void	setParticipantType (ParticipantType const p)

G4bool	isParticipant () const

G4bool	isTargetSpectator () const

G4bool	isProjectileSpectator () const

G4bool	isPion () const
	Is this a pion? More...

G4bool	isResonance () const
	Is it a resonance? More...

G4bool	isDelta () const
	Is it a Delta? More...

G4int	getA () const
	Returns the baryon number. More...

G4int	getZ () const
	Returns the charge number. More...

G4double	getBeta () const

ThreeVector	boostVector () const

void	boost (const ThreeVector &aBoostVector)

void	lorentzContract (const ThreeVector &aBoostVector, const ThreeVector &refPos)
	Lorentz-contract the particle position around some center. More...

G4double	getMass () const
	Get the cached particle mass. More...

G4double	getINCLMass () const
	Get the INCL particle mass. More...

G4double	getRealMass () const
	Get the real particle mass. More...

void	setRealMass ()
	Set the mass of the Particle to its real mass. More...

void	setTableMass ()
	Set the mass of the Particle to its table mass. More...

void	setINCLMass ()
	Set the mass of the Particle to its table mass. More...

G4double	getEmissionQValueCorrection (const G4int AParent, const G4int ZParent) const
	Computes correction on the emission Q-value. More...

G4double	getTransferQValueCorrection (const G4int AFrom, const G4int ZFrom, const G4int ATo, const G4int ZTo) const
	Computes correction on the transfer Q-value. More...

G4double	getInvariantMass () const
	Get the the particle invariant mass. More...

G4double	getKineticEnergy () const
	Get the particle kinetic energy. More...

G4double	getPotentialEnergy () const
	Get the particle potential energy. More...

void	setPotentialEnergy (G4double v)
	Set the particle potential energy. More...

G4double	getEnergy () const

void	setMass (G4double mass)

void	setEnergy (G4double energy)

const G4INCL::ThreeVector &	getMomentum () const

virtual void	setMomentum (const G4INCL::ThreeVector &momentum)

const G4INCL::ThreeVector &	getPosition () const

G4double	getHelicity ()

void	setHelicity (G4double h)

void	propagate (G4double step)

G4int	getNumberOfCollisions () const
	Return the number of collisions undergone by the particle. More...

void	setNumberOfCollisions (G4int n)
	Set the number of collisions undergone by the particle. More...

void	incrementNumberOfCollisions ()
	Increment the number of collisions undergone by the particle. More...

G4int	getNumberOfDecays () const
	Return the number of decays undergone by the particle. More...

void	setNumberOfDecays (G4int n)
	Set the number of decays undergone by the particle. More...

void	incrementNumberOfDecays ()
	Increment the number of decays undergone by the particle. More...

void	setOutOfWell ()
	Mark the particle as out of its potential well. More...

G4bool	isOutOfWell () const
	Check if the particle is out of its potential well. More...

void	setEmissionTime (G4double t)

G4double	getEmissionTime ()

ThreeVector	getTransversePosition () const
	Transverse component of the position w.r.t. the momentum. More...

ThreeVector	getLongitudinalPosition () const
	Longitudinal component of the position w.r.t. the momentum. More...

const ThreeVector &	adjustMomentumFromEnergy ()
	Rescale the momentum to match the total energy. More...

G4double	adjustEnergyFromMomentum ()
	Recompute the energy to match the momentum. More...

G4bool	isInList (ParticleList const &l) const
	Check if the particle belongs to a given list. More...

G4bool	isCluster () const

void	setFrozenMomentum (const ThreeVector &momentum)
	Set the frozen particle momentum. More...

void	setFrozenEnergy (const G4double energy)
	Set the frozen particle momentum. More...

ThreeVector	getFrozenMomentum () const
	Get the frozen particle momentum. More...

G4double	getFrozenEnergy () const
	Get the frozen particle momentum. More...

ThreeVector	getPropagationVelocity () const
	Get the propagation velocity of the particle. More...

void	freezePropagation ()
	Freeze particle propagation. More...

void	thawPropagation ()
	Unfreeze particle propagation. More...

std::string	print () const

std::string	dump () const

long	getID () const

ParticleList const *	getParticles () const

G4double	getReflectionMomentum () const
	Return the reflection momentum. More...

void	setUncorrelatedMomentum (const G4double p)
	Set the uncorrelated momentum. More...

void	rpCorrelate ()
	Make the particle follow a strict r-p correlation. More...

void	rpDecorrelate ()
	Make the particle not follow a strict r-p correlation. More...

G4double	getCosRPAngle () const
	Get the cosine of the angle between position and momentum. More...

Additional Inherited Members
Protected Member Functions inherited from G4INCL::Particle
void	swap (Particle &rhs)
	Helper method for the assignment operator. More...

Protected Attributes inherited from G4INCL::Cluster
ParticleList	particles

G4double	theExcitationEnergy

ThreeVector	theSpin

ParticleSampler *	theParticleSampler

Protected Attributes inherited from G4INCL::Particle
G4int	theZ

G4int	theA

ParticipantType	theParticipantType

G4INCL::ParticleType	theType

G4double	theEnergy

G4double *	thePropagationEnergy

G4double	theFrozenEnergy

G4INCL::ThreeVector	theMomentum

G4INCL::ThreeVector *	thePropagationMomentum

G4INCL::ThreeVector	theFrozenMomentum

G4INCL::ThreeVector	thePosition

G4int	nCollisions

G4int	nDecays

G4double	thePotentialEnergy

long	ID

G4bool	rpCorrelated

G4double	uncorrelatedMomentum

Detailed Description

Definition at line 59 of file G4INCLProjectileRemnant.hh.

Member Typedef Documentation

typedef std::map<long, G4double> G4INCL::ProjectileRemnant::EnergyLevelMap

Definition at line 64 of file G4INCLProjectileRemnant.hh.

typedef std::vector<G4double> G4INCL::ProjectileRemnant::EnergyLevels

Definition at line 63 of file G4INCLProjectileRemnant.hh.

Constructor & Destructor Documentation

G4INCL::ProjectileRemnant::ProjectileRemnant	(	ParticleSpecies const	species,
		const G4double	kineticEnergy
	)

inline

Definition at line 66 of file G4INCLProjectileRemnant.hh.

References G4INCL::Cluster::boost(), energy(), 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 97 of file G4INCLProjectileRemnant.hh.

References clearEnergyLevels(), G4INCL::Cluster::deleteParticles(), and deleteStoredComponents().

                          {
       deleteStoredComponents();
       // The ProjectileRemnant owns its particles
       deleteParticles();
       clearEnergyLevels();
     }

Member Function Documentation

ParticleList G4INCL::ProjectileRemnant::addAllDynamicalSpectators ( ParticleList pL )

Add back all dynamical spectators to the projectile remnant.

Return a list of rejected dynamical spectators.

Definition at line 143 of file G4INCLProjectileRemnant.cc.

References addMostDynamicalSpectators(), computeExcitationEnergyWith(), G4INCL::ParticleTable::getTableMass, INCL_DEBUG, INCL_WARN, G4INCL::ThreeVector::mag2(), G4INCL::Cluster::particles, G4INCL::Particle::theA, G4INCL::Particle::theEnergy, G4INCL::Particle::theMomentum, and G4INCL::Particle::theZ.

                                                                            {
     // Put all the spectators in the projectile
     ThreeVector theNewMomentum = theMomentum;
     G4double theNewEnergy = theEnergy;
     G4int theNewA = theA;
     G4int theNewZ = theZ;
     for(ParticleIter p=pL.begin(), e=pL.end(); p!=e; ++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 theNewExcitationEnergy = computeExcitationEnergyWith(pL);
     const G4double theNewEffectiveMass = theNewMass + theNewExcitationEnergy;
 
     // If this condition is satisfied, there is no solution. Fall back on the
     // "most" method
     if(theNewEnergy<theNewEffectiveMass) {
       INCL_WARN("Could not add all the dynamical spectators back into the projectile remnant."
            << " Falling back to the \"most\" method." << std::endl);
       return addMostDynamicalSpectators(pL);
     }
 
     // Add all the participants to the projectile remnant
     for(ParticleIter p=pL.begin(), e=pL.end(); p!=e; ++p) {
       particles.push_back(*p);
     }
 
     // Rescale the momentum of the projectile remnant so that sqrt(s) has the
     // correct value
     const G4double scalingFactorSquared = (theNewEnergy*theNewEnergy-theNewEffectiveMass*theNewEffectiveMass)/theNewMomentum.mag2();
     const G4double scalingFactor = std::sqrt(scalingFactorSquared);
     INCL_DEBUG("Scaling factor for the projectile-remnant momentum = " << scalingFactor << std::endl);
 
     theA = theNewA;
     theZ = theNewZ;
     theMomentum = theNewMomentum * scalingFactor;
     theEnergy = theNewEnergy;
 
     return ParticleList();
   }

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.

References G4INCL::UnorderedVector< T >::remove().

                                                                         {
     // 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(), e=toBeAdded.end(); p!=e; ++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 190 of file G4INCLProjectileRemnant.cc.

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

Referenced by addAllDynamicalSpectators().

                                                                             {
     // 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(), e=pL.end(); p!=e; ++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;
       ParticleMutableIter best = pL.end();
       ThreeVector bestMomentum;
       G4double bestEnergy = -1.;
       G4int bestA = -1, bestZ = -1;
       for(ParticleList::iterator p=pL.begin(), e=pL.end(); p!=e; ++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 = ((theNewerA>1) ? theNewerInvariantMass-theNewerMass : 0.);
           // 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(), e=pL.end(); p!=e; ++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 154 of file G4INCLProjectileRemnant.hh.

Referenced by ~ProjectileRemnant().

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

void G4INCL::ProjectileRemnant::clearStoredComponents ( )

inline

Clear the stored projectile components.

Definition at line 149 of file G4INCLProjectileRemnant.hh.

Referenced by deleteStoredComponents().

                                  {
       storedComponents.clear();
     }

G4double G4INCL::ProjectileRemnant::computeExcitationEnergyExcept ( const long exceptID ) const

Compute the excitation energy when a nucleon is removed.

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 315 of file G4INCLProjectileRemnant.cc.

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

                                                                                      {
     const EnergyLevels theEnergyLevels = getPresentEnergyLevelsExcept(exceptID);
     return computeExcitationEnergy(theEnergyLevels);
   }

G4double G4INCL::ProjectileRemnant::computeExcitationEnergyWith ( const ParticleList & pL ) const

Compute the excitation energy if some nucleons are put back.

Returns: the excitation energy

Definition at line 320 of file G4INCLProjectileRemnant.cc.

Referenced by addAllDynamicalSpectators().

                                                                                       {
     const EnergyLevels theEnergyLevels = getPresentEnergyLevelsWith(pL);
     return computeExcitationEnergy(theEnergyLevels);
   }

void G4INCL::ProjectileRemnant::deleteStoredComponents ( )

inline

Clear the stored projectile components and delete the particles.

Definition at line 142 of file G4INCLProjectileRemnant.hh.

References clearStoredComponents().

Referenced by ~ProjectileRemnant().

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

EnergyLevels const& G4INCL::ProjectileRemnant::getGroundStateEnergies ( ) const

inline

Definition at line 208 of file G4INCLProjectileRemnant.hh.

                                                        {
       return theGroundStateEnergies;
     }

G4int G4INCL::ProjectileRemnant::getNumberStoredComponents ( ) const

inline

Get the number of the stored components.

Definition at line 185 of file G4INCLProjectileRemnant.hh.

                                             {
       return storedComponents.size();
     }

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 G4INCL::Particle::getA(), G4INCL::Particle::getEnergy(), G4INCL::Particle::getMomentum(), G4INCL::Particle::getZ(), INCL_DEBUG, 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());
 
     INCL_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(), e=particles.end(); i!=e; ++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);
     INCL_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(), G4INCL::Cluster::deleteParticles(), G4INCL::Particle::getID(), INCL_DEBUG, 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();
     INCL_DEBUG("ProjectileRemnant object was reset:" << std::endl << print());
   }

void G4INCL::ProjectileRemnant::storeComponents ( )

inline

Store the projectile components.

Definition at line 177 of file G4INCLProjectileRemnant.hh.

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

Referenced by G4INCL::StandardPropagationModel::shootComposite().

                            {
       for(ParticleIter p=particles.begin(), e=particles.end(); p!=e; ++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 190 of file G4INCLProjectileRemnant.hh.

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

Referenced by ProjectileRemnant().

                              {
       EnergyLevels energies;
 
       for(ParticleIter p=particles.begin(), e=particles.end(); p!=e; ++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:

Public Types

Public Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation