G4INCL::ProjectileRemnant Class Reference

#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.
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.
ParticleList	addAllDynamicalSpectators (ParticleList const &pL)
	Add back all 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	computeExcitationEnergyExcept (const long exceptID) const
	Compute the excitation energy when a nucleon is removed.
G4double	computeExcitationEnergyWith (const ParticleList &pL) const
	Compute the excitation energy if some nucleons are put back.
void	storeComponents ()
	Store the projectile components.
G4int	getNumberStoredComponents () const
	Get the number of the stored components.
void	storeEnergyLevels ()
	Store the energy levels.
EnergyLevels const &	getGroundStateEnergies () const
Public Member Functions inherited from G4INCL::Cluster
	Cluster (const G4int Z, const G4int A, const G4int S, const G4bool createParticleSampler=true)
	Standard Cluster constructor.
template<class Iterator >
	Cluster (Iterator begin, Iterator end)
virtual	~Cluster ()
	Cluster (const Cluster &rhs)
	Copy constructor.
Cluster &	operator= (const Cluster &rhs)
	Assignment operator.
void	swap (Cluster &rhs)
	Helper method for the assignment operator.
ParticleSpecies	getSpecies () const
	Get the particle species.
void	deleteParticles ()
void	clearParticles ()
void	setZ (const G4int Z)
	Set the charge number of the cluster.
void	setA (const G4int A)
	Set the mass number of the cluster.
void	setS (const G4int S)
	Set the strangess number of the cluster.
G4double	getExcitationEnergy () const
	Get the excitation energy of the cluster.
void	setExcitationEnergy (const G4double e)
	Set the excitation energy of the cluster.
virtual G4double	getTableMass () const
	Get the real particle mass.
ParticleList const &	getParticles () const
void	removeParticle (Particle *const p)
	Remove a particle from the cluster components.
void	addParticle (Particle *const p)
void	updateClusterParameters ()
	Set total cluster mass, energy, size, etc. from the particles.
void	addParticles (ParticleList const &pL)
	Add a list of particles to the cluster.
ParticleList	getParticleList () const
	Returns the list of particles that make up the cluster.
std::string	print () const
virtual void	initializeParticles ()
	Initialise the NuclearDensity pointer and sample the particles.
void	internalBoostToCM ()
	Boost to the CM of the component particles.
void	putParticlesOffShell ()
	Put the cluster components off shell.
void	setPosition (const ThreeVector &position)
	Set the position of the cluster.
void	boost (const ThreeVector &aBoostVector)
	Boost the cluster with the indicated velocity.
void	freezeInternalMotion ()
	Freeze the internal motion of the particles.
virtual void	rotatePosition (const G4double angle, const ThreeVector &axis)
	Rotate position of all the particles.
virtual void	rotateMomentum (const G4double angle, const ThreeVector &axis)
	Rotate momentum of all the particles.
virtual void	makeProjectileSpectator ()
	Make all the components projectile spectators, too.
virtual void	makeTargetSpectator ()
	Make all the components target spectators, too.
virtual void	makeParticipant ()
	Make all the components participants, too.
ThreeVector const &	getSpin () const
	Get the spin of the nucleus.
void	setSpin (const ThreeVector &j)
	Set the spin of the nucleus.
G4INCL::ThreeVector	getAngularMomentum () const
	Get the total angular momentum (orbital + spin)
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.
Particle &	operator= (const Particle &rhs)
	Assignment operator.
G4INCL::ParticleType	getType () const
virtual G4INCL::ParticleSpecies	getSpecies () const
	Get the particle species.
void	setType (ParticleType t)
G4bool	isNucleon () const
ParticipantType	getParticipantType () const
void	setParticipantType (ParticipantType const p)
G4bool	isParticipant () const
G4bool	isTargetSpectator () const
G4bool	isProjectileSpectator () const
virtual void	makeParticipant ()
virtual void	makeTargetSpectator ()
virtual void	makeProjectileSpectator ()
G4bool	isPion () const
	Is this a pion?
G4bool	isEta () const
	Is this an eta?
G4bool	isOmega () const
	Is this an omega?
G4bool	isEtaPrime () const
	Is this an etaprime?
G4bool	isPhoton () const
	Is this a photon?
G4bool	isResonance () const
	Is it a resonance?
G4bool	isDelta () const
	Is it a Delta?
G4bool	isSigma () const
	Is this a Sigma?
G4bool	isKaon () const
	Is this a Kaon?
G4bool	isAntiKaon () const
	Is this an antiKaon?
G4bool	isLambda () const
	Is this a Lambda?
G4bool	isNucleonorLambda () const
	Is this a Nucleon or a Lambda?
G4bool	isHyperon () const
	Is this an Hyperon?
G4bool	isMeson () const
	Is this a Meson?
G4bool	isBaryon () const
	Is this a Baryon?
G4bool	isStrange () const
	Is this an Strange?
G4int	getA () const
	Returns the baryon number.
G4int	getZ () const
	Returns the charge number.
G4int	getS () const
	Returns the strangeness number.
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.
G4double	getMass () const
	Get the cached particle mass.
G4double	getINCLMass () const
	Get the INCL particle mass.
virtual G4double	getTableMass () const
	Get the tabulated particle mass.
G4double	getRealMass () const
	Get the real particle mass.
void	setRealMass ()
	Set the mass of the Particle to its real mass.
void	setTableMass ()
	Set the mass of the Particle to its table mass.
void	setINCLMass ()
	Set the mass of the Particle to its table mass.
G4double	getEmissionQValueCorrection (const G4int AParent, const G4int ZParent) const
	Computes correction on the emission Q-value.
G4double	getTransferQValueCorrection (const G4int AFrom, const G4int ZFrom, const G4int ATo, const G4int ZTo) const
	Computes correction on the transfer Q-value.
G4double	getEmissionQValueCorrection (const G4int AParent, const G4int ZParent, const G4int SParent) const
	Computes correction on the emission Q-value for hypernuclei.
G4double	getTransferQValueCorrection (const G4int AFrom, const G4int ZFrom, const G4int SFrom, const G4int ATo, const G4int ZTo, const G4int STo) const
	Computes correction on the transfer Q-value for hypernuclei.
G4double	getInvariantMass () const
	Get the the particle invariant mass.
G4double	getKineticEnergy () const
	Get the particle kinetic energy.
G4double	getPotentialEnergy () const
	Get the particle potential energy.
void	setPotentialEnergy (G4double v)
	Set the particle potential energy.
G4double	getEnergy () const
void	setMass (G4double mass)
void	setEnergy (G4double energy)
const G4INCL::ThreeVector &	getMomentum () const
virtual G4INCL::ThreeVector	getAngularMomentum () const
virtual void	setMomentum (const G4INCL::ThreeVector &momentum)
const G4INCL::ThreeVector &	getPosition () const
virtual void	setPosition (const G4INCL::ThreeVector &position)
G4double	getHelicity ()
void	setHelicity (G4double h)
void	propagate (G4double step)
G4int	getNumberOfCollisions () const
	Return the number of collisions undergone by the particle.
void	setNumberOfCollisions (G4int n)
	Set the number of collisions undergone by the particle.
void	incrementNumberOfCollisions ()
	Increment the number of collisions undergone by the particle.
G4int	getNumberOfDecays () const
	Return the number of decays undergone by the particle.
void	setNumberOfDecays (G4int n)
	Set the number of decays undergone by the particle.
void	incrementNumberOfDecays ()
	Increment the number of decays undergone by the particle.
void	setOutOfWell ()
	Mark the particle as out of its potential well.
G4bool	isOutOfWell () const
	Check if the particle is out of its potential well.
void	setEmissionTime (G4double t)
G4double	getEmissionTime ()
ThreeVector	getTransversePosition () const
	Transverse component of the position w.r.t. the momentum.
ThreeVector	getLongitudinalPosition () const
	Longitudinal component of the position w.r.t. the momentum.
const ThreeVector &	adjustMomentumFromEnergy ()
	Rescale the momentum to match the total energy.
G4double	adjustEnergyFromMomentum ()
	Recompute the energy to match the momentum.
G4bool	isCluster () const
void	setFrozenMomentum (const ThreeVector &momentum)
	Set the frozen particle momentum.
void	setFrozenEnergy (const G4double energy)
	Set the frozen particle momentum.
ThreeVector	getFrozenMomentum () const
	Get the frozen particle momentum.
G4double	getFrozenEnergy () const
	Get the frozen particle momentum.
ThreeVector	getPropagationVelocity () const
	Get the propagation velocity of the particle.
void	freezePropagation ()
	Freeze particle propagation.
void	thawPropagation ()
	Unfreeze particle propagation.
virtual void	rotatePositionAndMomentum (const G4double angle, const ThreeVector &axis)
	Rotate the particle position and momentum.
virtual void	rotatePosition (const G4double angle, const ThreeVector &axis)
	Rotate the particle position.
virtual void	rotateMomentum (const G4double angle, const ThreeVector &axis)
	Rotate the particle momentum.
std::string	print () const
std::string	dump () const
long	getID () const
ParticleList const *	getParticles () const
G4double	getReflectionMomentum () const
	Return the reflection momentum.
void	setUncorrelatedMomentum (const G4double p)
	Set the uncorrelated momentum.
void	rpCorrelate ()
	Make the particle follow a strict r-p correlation.
void	rpDecorrelate ()
	Make the particle not follow a strict r-p correlation.
G4double	getCosRPAngle () const
	Get the cosine of the angle between position and momentum.
G4double	getParticleBias () const
	Get the particle bias.
void	setParticleBias (G4double ParticleBias)
	Set the particle bias.
std::vector< G4int >	getBiasCollisionVector () const
	Get the vector list of biased vertices on the particle path.
void	setBiasCollisionVector (std::vector< G4int > BiasCollisionVector)
	Set the vector list of biased vertices on the particle path.
G4int	getNumberOfKaon () const
	Number of Kaon inside de nucleus.
void	setNumberOfKaon (const G4int NK)

Additional Inherited Members
Static Public Member Functions inherited from G4INCL::Particle
static G4double	getTotalBias ()
	General bias vector function.
static void	setINCLBiasVector (std::vector< G4double > NewVector)
static void	FillINCLBiasVector (G4double newBias)
static G4double	getBiasFromVector (std::vector< G4int > VectorBias)
static std::vector< G4int >	MergeVectorBias (Particle const *const p1, Particle const *const p2)
static std::vector< G4int >	MergeVectorBias (std::vector< G4int > p1, Particle const *const p2)
Static Public Attributes inherited from G4INCL::Particle
static std::vector< G4double >	INCLBiasVector
	Time ordered vector of all bias applied.
static G4ThreadLocal G4int	nextBiasedCollisionID = 0
Protected Member Functions inherited from G4INCL::Particle
void	swap (Particle &rhs)
	Helper method for the assignment operator.
Protected Attributes inherited from G4INCL::Cluster
ParticleList	particles
G4double	theExcitationEnergy
ThreeVector	theSpin
ParticleSampler *	theParticleSampler
Protected Attributes inherited from G4INCL::Particle
G4int	theZ
G4int	theA
G4int	theS
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
G4double	theParticleBias
G4int	theNKaon
	The number of Kaons inside the nucleus (update during the cascade)

Detailed Description

Definition at line 58 of file G4INCLProjectileRemnant.hh.

Member Typedef Documentation

EnergyLevelMap

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

Definition at line 63 of file G4INCLProjectileRemnant.hh.

EnergyLevels

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

Definition at line 62 of file G4INCLProjectileRemnant.hh.

Constructor & Destructor Documentation

ProjectileRemnant()

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

inline

Definition at line 65 of file G4INCLProjectileRemnant.hh.

      : Cluster(species.theZ, species.theA, species.theS) {
 
      // 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();
    }

~ProjectileRemnant()

G4INCL::ProjectileRemnant::~ProjectileRemnant ( )

inline

Definition at line 96 of file G4INCLProjectileRemnant.hh.

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

Member Function Documentation

addAllDynamicalSpectators()

ParticleList G4INCL::ProjectileRemnant::addAllDynamicalSpectators

(

ParticleList const &

pL

)

Add back all dynamical spectators to the projectile remnant.

Return a list of rejected dynamical spectators.

Definition at line 144 of file G4INCLProjectileRemnant.cc.

                                                                                  {
    // Put all the spectators in the projectile
    ThreeVector theNewMomentum = theMomentum;
    G4double theNewEnergy = theEnergy;
    G4int theNewA = theA;
    G4int theNewZ = theZ;
    G4int theNewS = theS;
    for(ParticleIter p=pL.begin(), e=pL.end(); p!=e; ++p) {
// assert((*p)->isNucleonorLambda());
      // Add the initial (off-shell) momentum and energy to the projectile remnant
      theNewMomentum += getStoredMomentum(*p);
      theNewEnergy += (*p)->getEnergy();
      theNewA += (*p)->getA();
      theNewZ += (*p)->getZ();
      theNewS += (*p)->getS();
    }
 
    // Check that the excitation energy of the new projectile remnant is non-negative
    const G4double theNewMass = ParticleTable::getTableMass(theNewA,theNewZ,theNewS);
    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." << '\n');
      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 << '\n');
 
    theA = theNewA;
    theZ = theNewZ;
    theS = theNewS;
    theMomentum = theNewMomentum * scalingFactor;
    theEnergy = theNewEnergy;
 
    return ParticleList();
  }

addDynamicalSpectators()

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 121 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;
    unsigned long loopCounter = 0;
    const unsigned long maxLoopCounter = 10000000;
    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++;
        }
      }
      ++loopCounter;
    } while(loopCounter<maxLoopCounter && accepted > 0); /* Loop checking, 10.07.2015, D.Mancusi */
    return pL;
  }

addMostDynamicalSpectators()

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 194 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. 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;
    G4int theNewS = theS;
    for(ParticleIter p=pL.begin(), e=pL.end(); p!=e; ++p) {
// assert((*p)->isNucleonorLambda());
      // Add the initial (off-shell) momentum and energy to the projectile remnant
      theNewMomentum += getStoredMomentum(*p);
      theNewEnergy += (*p)->getEnergy();
      theNewA += (*p)->getA();
      theNewZ += (*p)->getZ();
      theNewS += (*p)->getS();
    }
 
    // Check that the excitation energy of the new projectile remnant is non-negative
    const G4double theNewMass = ParticleTable::getTableMass(theNewA,theNewZ,theNewS);
    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()) { /* Loop checking, 10.07.2015, D.Mancusi */
      G4double maxExcitationEnergy = -1.E30;
      ParticleMutableIter best = pL.end();
      ThreeVector bestMomentum;
      G4double bestEnergy = -1.;
      G4int bestA = -1, bestZ = -1, bestS = 0;
      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 G4int theNewerS = theNewS - (*p)->getS();
 
        const G4double theNewerMass = ParticleTable::getTableMass(theNewerA,theNewerZ,theNewerS);
        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;
            bestS = theNewerS;
          }
        }
      }
 
      // 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;
      theNewS = bestS;
 
      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;
    theS = theNewS;
    theMomentum = theNewMomentum;
    theEnergy = theNewEnergy;
 
    return rejected;
  }

Referenced by addAllDynamicalSpectators().

clearEnergyLevels()

void G4INCL::ProjectileRemnant::clearEnergyLevels ( )

inline

Clear the stored energy levels.

Definition at line 153 of file G4INCLProjectileRemnant.hh.

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

Referenced by ~ProjectileRemnant().

clearStoredComponents()

void G4INCL::ProjectileRemnant::clearStoredComponents ( )

inline

Clear the stored projectile components.

Definition at line 148 of file G4INCLProjectileRemnant.hh.

                                 {
      storedComponents.clear();
    }

Referenced by deleteStoredComponents().

computeExcitationEnergyExcept()

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

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

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

computeExcitationEnergyWith()

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

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

Referenced by addAllDynamicalSpectators().

deleteStoredComponents()

void G4INCL::ProjectileRemnant::deleteStoredComponents ( )

inline

Clear the stored projectile components and delete the particles.

Definition at line 141 of file G4INCLProjectileRemnant.hh.

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

Referenced by ~ProjectileRemnant().

getGroundStateEnergies()

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

inline

Definition at line 207 of file G4INCLProjectileRemnant.hh.

                                                       {
      return theGroundStateEnergies;
    }

getNumberStoredComponents()

G4int G4INCL::ProjectileRemnant::getNumberStoredComponents ( ) const

inline

Get the number of the stored components.

Definition at line 184 of file G4INCLProjectileRemnant.hh.

                                            {
      return storedComponents.size();
    }

removeParticle()

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

                                                                                                   {
// assert(p->isNucleon());
 
    INCL_DEBUG("The following Particle is about to be removed from the ProjectileRemnant:"
        << '\n' << p->print()
        << "theProjectileCorrection=" << theProjectileCorrection << '\n');
    // 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:"
        << '\n' << print());
  }

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

reset()

void G4INCL::ProjectileRemnant::reset

(

)

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

Definition at line 51 of file G4INCLProjectileRemnant.cc.

                                {
    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);
    }
    if(theA>0)
      thePosition /= theA;
    setTableMass();
    INCL_DEBUG("ProjectileRemnant object was reset:" << '\n' << print());
  }

storeComponents()

void G4INCL::ProjectileRemnant::storeComponents ( )

inline

Store the projectile components.

Definition at line 176 of file G4INCLProjectileRemnant.hh.

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

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

storeEnergyLevels()

void G4INCL::ProjectileRemnant::storeEnergyLevels ( )

inline

Store the energy levels.

Definition at line 189 of file G4INCLProjectileRemnant.hh.

                             {
      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());
    }

Referenced by ProjectileRemnant().

---

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

• G4INCLProjectileRemnant.hh
• G4INCLProjectileRemnant.cc