G4INCL::Nucleus Class Reference

#include <G4INCLNucleus.hh>

Inheritance diagram for G4INCL::Nucleus:

Classes
struct	ConservationBalance
	Struct for conservation laws. More...

Public Member Functions
	Nucleus (G4int mass, G4int charge, G4int strangess, Config const *const conf, const G4double universeRadius=-1., AnnihilationType AType=Def)
virtual	~Nucleus ()
	Nucleus (const Nucleus &rhs)
	Dummy copy constructor to silence Coverity warning.
Nucleus &	operator= (const Nucleus &rhs)
	Dummy assignment operator to silence Coverity warning.
AnnihilationType	getAType () const
void	setAType (AnnihilationType type)
void	initializeParticles ()
void	insertParticle (Particle *p)
	Insert a new particle (e.g. a projectile) in the nucleus.
void	applyFinalState (FinalState *)
G4int	getInitialA () const
G4int	getInitialZ () const
G4int	getInitialS () const
void	propagateParticles (G4double step)
G4int	getNumberOfEnteringProtons () const
G4int	getNumberOfEnteringNeutrons () const
G4int	getNumberOfEnteringPions () const
G4int	getNumberOfEnteringKaons () const
G4int	getNumberOfEnteringantiProtons () const
G4int	getNumberOfEnteringantiNeutrons () const
G4double	computeSeparationEnergyBalance () const
	Outgoing - incoming separation energies.
G4bool	decayOutgoingDeltas ()
	Force the decay of outgoing deltas.
G4bool	decayInsideDeltas ()
	Force the decay of deltas inside the nucleus.
G4bool	decayInsideStrangeParticles ()
	Force the transformation of strange particles into a Lambda;.
G4bool	decayOutgoingPionResonances (G4double timeThreshold)
	Force the decay of outgoing PionResonances (eta/omega).
G4bool	decayOutgoingSigmaZero (G4double timeThreshold)
	Force the decay of outgoing Neutral Sigma.
G4bool	decayOutgoingNeutralKaon ()
	Force the transformation of outgoing Neutral Kaon into propation eigenstate.
G4bool	decayOutgoingClusters ()
	Force the decay of unstable outgoing clusters.
G4bool	decayMe ()
	Force the phase-space decay of the Nucleus.
void	emitInsidePions ()
	Force emission of all pions inside the nucleus.
void	emitInsideStrangeParticles ()
	Force emission of all strange particles inside the nucleus.
G4int	emitInsideLambda ()
	Force emission of all Lambda (desexitation code with strangeness not implanted yet).
G4int	emitInsideAntilambda ()
	Force emission of all Antilambda.
G4bool	emitInsideKaon ()
	Force emission of all Kaon inside the nucleus.
G4bool	emitInsideAnnihilationProducts ()
	Force emission of all Antinucleon inside the nucleus.
void	computeRecoilKinematics ()
	Compute the recoil momentum and spin of the nucleus.
ThreeVector	computeCenterOfMass () const
	Compute the current center-of-mass position.
G4double	computeTotalEnergy () const
	Compute the current total energy.
G4double	computeExcitationEnergy () const
	Compute the current excitation energy.
void	setIncomingAngularMomentum (const ThreeVector &j)
	Set the incoming angular-momentum vector.
const ThreeVector &	getIncomingAngularMomentum () const
	Get the incoming angular-momentum vector.
void	setIncomingMomentum (const ThreeVector &p)
	Set the incoming momentum vector.
const ThreeVector &	getIncomingMomentum () const
	Get the incoming momentum vector.
void	setInitialEnergy (const G4double e)
	Set the initial energy.
G4double	getInitialEnergy () const
	Get the initial energy.
G4double	getExcitationEnergy () const
	Get the excitation energy of the nucleus.
G4bool	containsDeltas ()
	Returns true if the nucleus contains any deltas.
G4bool	containsAntiKaon ()
	Returns true if the nucleus contains any anti Kaons.
G4bool	containsLambda ()
	Returns true if the nucleus contains any Lambda.
G4bool	containsAntilambda ()
	Returns true if the nucleus contains any Antilambda.
G4bool	containsSigma ()
	Returns true if the nucleus contains any Sigma.
G4bool	containsKaon ()
	Returns true if the nucleus contains any Kaons.
G4bool	containsAntinucleon ()
	Returns true if the nucleus contains any Antinucleons.
G4bool	containsEtas ()
	Returns true if the nucleus contains any etas.
G4bool	containsOmegas ()
	Returns true if the nucleus contains any omegas.
void	resetSrc ()
	Resets the src partners.
void	setSrcInternalEnergy (double value)
void	updateInternalEnergy (double value)
G4double	getSrcInternalEnergy () const
std::string	print ()
Store *	getStore () const
void	setStore (Store *str)
G4double	getInitialInternalEnergy () const
G4bool	isEventTransparent () const
	Is the event transparent?
G4bool	hasRemnant () const
	Does the nucleus give a cascade remnant?
void	fillEventInfo (EventInfo *eventInfo)
G4bool	getTryCompoundNucleus ()
G4double	getTransmissionBarrier (Particle const *const p)
	Get the transmission barrier.
void	restoreSrcPartner (Particle *particle, ThreeVector m)
ConservationBalance	getConservationBalance (EventInfo const &theEventInfo, const G4bool afterRecoil) const
	Compute charge, mass, energy and momentum balance.
void	useFusionKinematics ()
	Adjust the kinematics for complete-fusion events.
G4double	getSurfaceRadius (Particle const *const particle) const
	Get the maximum allowed radius for a given particle.
G4double	getUniverseRadius () const
	Getter for theUniverseRadius.
void	setUniverseRadius (const G4double universeRadius)
	Setter for theUniverseRadius.
G4bool	isNucleusNucleusCollision () const
	Is it a nucleus-nucleus collision?
void	setNucleusNucleusCollision ()
	Set a nucleus-nucleus collision.
void	setParticleNucleusCollision ()
	Set a particle-nucleus collision.
void	setProjectileRemnant (ProjectileRemnant *const c)
	Set the projectile remnant.
ProjectileRemnant *	getProjectileRemnant () const
	Get the projectile remnant.
void	deleteProjectileRemnant ()
	Delete the projectile remnant.
void	finalizeProjectileRemnant (const G4double emissionTime)
	Finalise the projectile remnant.
void	updatePotentialEnergy (Particle *p) const
	Update the particle potential energy.
void	setDensity (NuclearDensity const *const d)
	Setter for theDensity.
NuclearDensity const *	getDensity () const
	Getter for theDensity.
NuclearPotential::INuclearPotential const *	getPotential () const
	Getter for thePotential.
AnnihilationType	getAnnihilationType () const
	Getter for theAnnihilationType.
void	setAnnihilationType (const AnnihilationType at)
	Setter for theAnnihilationType.
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
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
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?
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 a Strange?
G4bool	isXi () const
	Is this a Xi?
G4bool	isAntiNucleon () const
	Is this an antinucleon?
G4bool	isAntiSigma () const
	Is this an antiSigma?
G4bool	isAntiXi () const
	Is this an antiXi?
G4bool	isAntiLambda () const
	Is this an antiLambda?
G4bool	isAntiHyperon () const
	Is this an antiHyperon?
G4bool	isAntiBaryon () const
	Is this an antiBaryon?
G4bool	isAntiNucleonorAntiLambda () const
	Is this an antiNucleon or an antiLambda?
G4int	getA () const
	Returns the baryon number.
G4int	getZ () const
	Returns the charge number.
G4int	getS () const
	Returns the strangeness number.
G4int	getSrcPair () 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.
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 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.
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	setNumberOfSrcPair (int n)
	Set the number of srcpairs.
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	setSrcPartner ()
	Set and reset src partner.
void	resetSrcPartner ()
G4bool	isSrcPartner () const
	Check if the particle is a src partner.
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.
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)
G4int	getParentResonancePDGCode () const
void	setParentResonancePDGCode (const G4int parentPDGCode)
G4int	getParentResonanceID () const
void	setParentResonanceID (const G4int parentID)

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
G4int	nSrcPair
G4double	thePotentialEnergy
long	ID
G4bool	rpCorrelated
G4double	uncorrelatedMomentum
G4double	theParticleBias
G4int	theNKaon
	The number of Kaons inside the nucleus (update during the cascade).
G4int	theParentResonancePDGCode
G4int	theParentResonanceID

Detailed Description

Definition at line 67 of file G4INCLNucleus.hh.

Constructor & Destructor Documentation

Nucleus() [1/2]

G4INCL::Nucleus::Nucleus	(	G4int	mass,
		G4int	charge,
		G4int	strangess,
		Config const *const	conf,
		const G4double	universeRadius = -1.,
		AnnihilationType	AType = Def )

Definition at line 70 of file G4INCLNucleus.cc.

    : Cluster(charge,mass,strangess,true),
     theInitialZ(charge), theInitialA(mass), theInitialS(strangess),
     theNpInitial(0), theNnInitial(0), 
     theNlInitial(0),
     theNSpInitial(0), theNSzInitial(0), theNSmInitial(0), 
     theNpionplusInitial(0), theNpionminusInitial(0), 
     theNkaonplusInitial(0), theNkaonminusInitial(0),
     theNantiprotonInitial(0),theNantineutronInitial(0),
     initialInternalEnergy(0.), srcInternalEnergy(0.), 
     incomingAngularMomentum(0.,0.,0.), incomingMomentum(0.,0.,0.),
     initialCenterOfMass(0.,0.,0.),
     remnant(true),
     initialEnergy(0.),
     tryCN(false),
     theUniverseRadius(universeRadius),
     isNucleusNucleus(false),
     theProjectileRemnant(NULL),
     theDensity(NULL),
     thePotential(NULL),
     theAType(AType)
  {
    PotentialType potentialType;
    G4bool pionPotential;
    if(conf) {
      potentialType = conf->getPotentialType();
      pionPotential = conf->getPionPotential();
    } else { // By default we don't use energy dependent
      // potential. This is convenient for some tests.
      potentialType = IsospinPotential;
      pionPotential = true;
    }
 
    thePotential = NuclearPotential::createPotential(potentialType, theA, theZ, pionPotential);
 
    ParticleTable::setProtonSeparationEnergy(thePotential->getSeparationEnergy(Proton));
    ParticleTable::setNeutronSeparationEnergy(thePotential->getSeparationEnergy(Neutron));
 
    if (theAType==PType) theDensity = NuclearDensityFactory::createDensity(theA+1, theZ+1, theS);
    else if (theAType==NType) theDensity = NuclearDensityFactory::createDensity(theA+1, theZ, theS);
    else if (theAType==DNbarNPbarNType) theDensity = NuclearDensityFactory::createDensity(theA+2, theZ, theS);
    else if (theAType==DNbarPPbarPType) theDensity = NuclearDensityFactory::createDensity(theA+2, theZ+2, theS);
    else if (theAType==DNbarPPbarNType || theAType==DNbarNPbarPType) theDensity = NuclearDensityFactory::createDensity(theA+2, theZ+1, theS);
    else
    theDensity = NuclearDensityFactory::createDensity(theA, theZ, theS);
 
    theParticleSampler->setPotential(thePotential);
    theParticleSampler->setDensity(theDensity);
 
    if(theUniverseRadius<0)
      theUniverseRadius = theDensity->getMaximumRadius();
    theStore = new Store(conf);
  }

Referenced by Nucleus(), and operator=().

~Nucleus()

G4INCL::Nucleus::~Nucleus ( )

virtual

Definition at line 125 of file G4INCLNucleus.cc.

                    {
    delete theStore;
    deleteProjectileRemnant();
    /* We don't delete the potential and the density here any more -- Factories
     * are caching them
    delete thePotential;
    delete theDensity;*/
  }

Nucleus() [2/2]

G4INCL::Nucleus::Nucleus

(

const Nucleus &

rhs

)

Dummy copy constructor to silence Coverity warning.

Member Function Documentation

applyFinalState()

void G4INCL::Nucleus::applyFinalState

(

FinalState *

finalstate

)

Apply reaction final state information to the nucleus.

Definition at line 157 of file G4INCLNucleus.cc.

                                                      {
    if(!finalstate) // do nothing if no final state was returned
      return;
 
    G4double totalEnergy = 0.0;
 
    FinalStateValidity const validity = finalstate->getValidity();
    if(validity == ValidFS) {
 
      ParticleList const &created = finalstate->getCreatedParticles();
      for(ParticleIter iter=created.begin(), e=created.end(); iter!=e; ++iter) {
        theStore->add((*iter));
        if(!(*iter)->isOutOfWell()) {
          totalEnergy += (*iter)->getEnergy() - (*iter)->getPotentialEnergy();
        }
      }
 
      ParticleList const &deleted = finalstate->getDestroyedParticles();
      for(ParticleIter iter=deleted.begin(), e=deleted.end(); iter!=e; ++iter) {
        theStore->particleHasBeenDestroyed(*iter);
      }
 
      ParticleList const &modified = finalstate->getModifiedParticles();
      for(ParticleIter iter=modified.begin(), e=modified.end(); iter!=e; ++iter) {
        theStore->particleHasBeenUpdated(*iter);
        totalEnergy += (*iter)->getEnergy() - (*iter)->getPotentialEnergy();
      }
 
      ParticleList const &out = finalstate->getOutgoingParticles();
      for(ParticleIter iter=out.begin(), e=out.end(); iter!=e; ++iter) {
        if((*iter)->isCluster()) {
      Cluster *clusterOut = dynamic_cast<Cluster*>((*iter));
// assert(clusterOut);
#ifdef INCLXX_IN_GEANT4_MODE
          if(!clusterOut)
            continue;
#endif
          ParticleList const &components = clusterOut->getParticles();
          for(ParticleIter in=components.begin(), end=components.end(); in!=end; ++in)
            theStore->particleHasBeenEjected(*in);
        } else {
          theStore->particleHasBeenEjected(*iter);
        }
        totalEnergy += (*iter)->getEnergy();      // No potential here because the particle is gone
        theA -= (*iter)->getA();
        theZ -= (*iter)->getZ();
        theS -= (*iter)->getS();
        theStore->addToOutgoing(*iter);
        (*iter)->setEmissionTime(theStore->getBook().getCurrentTime());
      }
 
      ParticleList const &entering = finalstate->getEnteringParticles();
      for(ParticleIter iter=entering.begin(), e=entering.end(); iter!=e; ++iter) {
        insertParticle(*iter);
        totalEnergy += (*iter)->getEnergy() - (*iter)->getPotentialEnergy();
      }
 
      // actually perform the removal of the scheduled avatars
      theStore->removeScheduledAvatars();
    } else if(validity == ParticleBelowFermiFS || validity == ParticleBelowZeroFS) {
      INCL_DEBUG("A Particle is entering below the Fermi sea:" << '\n' << finalstate->print() << '\n');
      tryCN = true;
      ParticleList const &entering = finalstate->getEnteringParticles();
      for(ParticleIter iter=entering.begin(), e=entering.end(); iter!=e; ++iter) {
        insertParticle(*iter);
      }
    }
 
    if(validity==ValidFS &&
        std::abs(totalEnergy - finalstate->getTotalEnergyBeforeInteraction()) > 0.1) {
      INCL_ERROR("Energy nonconservation! Energy at the beginning of the event = "
          << finalstate->getTotalEnergyBeforeInteraction()
          <<" and after interaction = "
          << totalEnergy << '\n'
          << finalstate->print());
    }
  }

Referenced by decayInsideDeltas(), decayInsideStrangeParticles(), and emitInsideAnnihilationProducts().

computeCenterOfMass()

ThreeVector G4INCL::Nucleus::computeCenterOfMass

(

)

const

Compute the current center-of-mass position.

Returns

the center-of-mass position vector [fm].

Definition at line 292 of file G4INCLNucleus.cc.

                                                 {
    ThreeVector cm(0.,0.,0.);
    G4double totalMass = 0.0;
    ParticleList const &inside = theStore->getParticles();
    for(ParticleIter p=inside.begin(), e=inside.end(); p!=e; ++p) {
      const G4double mass = (*p)->getMass();
      cm += (*p)->getPosition() * mass;
      totalMass += mass;
    }
    cm /= totalMass;
    return cm;
  }

Referenced by computeRecoilKinematics().

computeExcitationEnergy()

G4double G4INCL::Nucleus::computeExcitationEnergy

(

)

const

Compute the current excitation energy.

Returns

the excitation energy [MeV]

Definition at line 305 of file G4INCLNucleus.cc.

                                                  {
    const G4double totalEnergy = computeTotalEnergy();
    const G4double separationEnergies = computeSeparationEnergyBalance();
 
  return totalEnergy - initialInternalEnergy - separationEnergies;
  
  }

computeRecoilKinematics()

void G4INCL::Nucleus::computeRecoilKinematics

(

)

Compute the recoil momentum and spin of the nucleus.

Definition at line 259 of file G4INCLNucleus.cc.

                                        {
    // If the remnant consists of only one nucleon, we need to apply a special
    // procedure to put it on mass shell.
    if(theA==1) {
      emitInsidePions();
      computeOneNucleonRecoilKinematics();
      remnant=false;
      return;
    }
 
    // Compute the recoil momentum and angular momentum
    theMomentum = incomingMomentum;
    theSpin = incomingAngularMomentum;
 
    ParticleList const &outgoing = theStore->getOutgoingParticles();
    for(ParticleIter p=outgoing.begin(), e=outgoing.end(); p!=e; ++p) {
      theMomentum -= (*p)->getMomentum();
      theSpin -= (*p)->getAngularMomentum();
    }
    if(theProjectileRemnant) {
      theMomentum -= theProjectileRemnant->getMomentum();
      theSpin -= theProjectileRemnant->getAngularMomentum();
    }
 
    // Subtract orbital angular momentum
    thePosition = computeCenterOfMass();
    theSpin -= (thePosition-initialCenterOfMass).vector(theMomentum);
 
    setMass(ParticleTable::getTableMass(theA,theZ,theS) + theExcitationEnergy);
    adjustEnergyFromMomentum();
    remnant=true;
  }

computeSeparationEnergyBalance()

G4double G4INCL::Nucleus::computeSeparationEnergyBalance ( ) const

inline

Outgoing - incoming separation energies.

Used by CDPP.

Definition at line 148 of file G4INCLNucleus.hh.

                                                    {
      G4double S = 0.0;
      ParticleList const &outgoing = theStore->getOutgoingParticles();
      for(ParticleIter i=outgoing.begin(), e=outgoing.end(); i!=e; ++i) {
        const ParticleType t = (*i)->getType();
        switch(t) {
          case Proton:
          case Neutron:
          case DeltaPlusPlus:
          case DeltaPlus:
          case DeltaZero:
          case DeltaMinus:
          case Lambda:
          case PiPlus:
          case PiMinus:
          case KPlus:
          case KMinus:
          case KZero:
          case KZeroBar:
          case KShort:
          case KLong:
          case SigmaPlus:
          case SigmaZero:
          case SigmaMinus:
            S += thePotential->getSeparationEnergy(*i);
            break;
          case antiSigmaPlus:
          case antiSigmaZero:
          case antiSigmaMinus:
          case antiLambda:
          case antiProton:
          case antiNeutron:
            S -= thePotential->getSeparationEnergy(*i);
            break;
          case Composite:
            S += (*i)->getZ() * thePotential->getSeparationEnergy(Proton)
              + ((*i)->getA() + (*i)->getS() - (*i)->getZ()) * thePotential->getSeparationEnergy(Neutron) 
              - (*i)->getS() * thePotential->getSeparationEnergy(Lambda);
            break;
          case antiComposite:
            S -= (*i)->getZ() * thePotential->getSeparationEnergy(antiProton)
              + ((*i)->getA() + (*i)->getS() - (*i)->getZ()) * thePotential->getSeparationEnergy(antiNeutron);
            break;
          default:
            break;
        }
      }
 
      S -= theNpInitial * thePotential->getSeparationEnergy(Proton);
      S -= theNnInitial * thePotential->getSeparationEnergy(Neutron);
      S -= theNlInitial * thePotential->getSeparationEnergy(Lambda);
      S -= theNSpInitial * thePotential->getSeparationEnergy(SigmaPlus);
      S -= theNSzInitial * thePotential->getSeparationEnergy(SigmaZero);
      S -= theNSmInitial * thePotential->getSeparationEnergy(SigmaMinus);
      S -= theNpionplusInitial*thePotential->getSeparationEnergy(PiPlus);;
      S -= theNkaonplusInitial*thePotential->getSeparationEnergy(KPlus);
      S -= theNpionminusInitial*thePotential->getSeparationEnergy(PiMinus);
      S -= theNkaonminusInitial*thePotential->getSeparationEnergy(KMinus);
      S += theNantiprotonInitial*thePotential->getSeparationEnergy(antiProton);
      S += theNantineutronInitial*thePotential->getSeparationEnergy(antiNeutron);
      return S;
    }

Referenced by computeExcitationEnergy().

computeTotalEnergy()

G4double G4INCL::Nucleus::computeTotalEnergy

(

)

const

Compute the current total energy.

Returns

the total energy [MeV]

Definition at line 239 of file G4INCLNucleus.cc.

                                             {
    G4double totalEnergy = 0.0;
    ParticleList const &inside = theStore->getParticles();
    for(ParticleIter p=inside.begin(), e=inside.end(); p!=e; ++p) {
      if((*p)->isNucleon()) // Ugly: we should calculate everything using total energies!
        totalEnergy += (*p)->getKineticEnergy() - (*p)->getPotentialEnergy();
      else if((*p)->isResonance())
        totalEnergy += (*p)->getEnergy() - (*p)->getPotentialEnergy() - ParticleTable::effectiveNucleonMass;
      else if((*p)->isHyperon())
        totalEnergy += (*p)->getEnergy() - (*p)->getPotentialEnergy() - ParticleTable::getRealMass((*p)->getType());
      //else if((*p)->isAntiLambda())
      //  totalEnergy += (*p)->getEnergy() - (*p)->getPotentialEnergy() + ParticleTable::getRealMass((*p)->getType()) - ParticleTable::getSeparationEnergyINCL(Lambda, theA, theZ);
        //std::cout << ParticleTable::getRealMass((*p)->getType()) << std::endl;}
      else
        totalEnergy += (*p)->getEnergy() - (*p)->getPotentialEnergy();
    }
 
    return totalEnergy;
  }

Referenced by computeExcitationEnergy(), and initializeParticles().

containsAntiKaon()

G4bool G4INCL::Nucleus::containsAntiKaon ( )

inline

Returns true if the nucleus contains any anti Kaons.

Definition at line 339 of file G4INCLNucleus.hh.

                                     {
      ParticleList const &inside = theStore->getParticles();
      for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
        if((*i)->isAntiKaon()) return true;
      return false;
    }

containsAntilambda()

G4bool G4INCL::Nucleus::containsAntilambda ( )

inline

Returns true if the nucleus contains any Antilambda.

Definition at line 355 of file G4INCLNucleus.hh.

                                       {
      ParticleList const &inside = theStore->getParticles();
      for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
        if((*i)->isAntiLambda()) return true;
      return false;
    }

containsAntinucleon()

G4bool G4INCL::Nucleus::containsAntinucleon ( )

inline

Returns true if the nucleus contains any Antinucleons.

Definition at line 379 of file G4INCLNucleus.hh.

                                        {
      ParticleList const &inside = theStore->getParticles();
      for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
        if((*i)->isAntiNucleon()) return true;
      return false;
    }

containsDeltas()

G4bool G4INCL::Nucleus::containsDeltas ( )

inline

Returns true if the nucleus contains any deltas.

Definition at line 331 of file G4INCLNucleus.hh.

                                   {
      ParticleList const &inside = theStore->getParticles();
      for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
        if((*i)->isDelta()) return true;
      return false;
    }

containsEtas()

G4bool G4INCL::Nucleus::containsEtas ( )

inline

Returns true if the nucleus contains any etas.

Definition at line 387 of file G4INCLNucleus.hh.

                                 {
      ParticleList const &inside = theStore->getParticles();
      for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
        if((*i)->isEta()) return true;
      return false;
    }

containsKaon()

G4bool G4INCL::Nucleus::containsKaon ( )

inline

Returns true if the nucleus contains any Kaons.

Definition at line 371 of file G4INCLNucleus.hh.

                                 {
      ParticleList const &inside = theStore->getParticles();
      for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
        if((*i)->isKaon()) return true;
      return false;
    }

containsLambda()

G4bool G4INCL::Nucleus::containsLambda ( )

inline

Returns true if the nucleus contains any Lambda.

Definition at line 347 of file G4INCLNucleus.hh.

                                   {
      ParticleList const &inside = theStore->getParticles();
      for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
        if((*i)->isLambda()) return true;
      return false;
    }

containsOmegas()

G4bool G4INCL::Nucleus::containsOmegas ( )

inline

Returns true if the nucleus contains any omegas.

Definition at line 395 of file G4INCLNucleus.hh.

                                   {
      ParticleList const &inside = theStore->getParticles();
      for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
        if((*i)->isOmega()) return true;
      return false;
    }

containsSigma()

G4bool G4INCL::Nucleus::containsSigma ( )

inline

Returns true if the nucleus contains any Sigma.

Definition at line 363 of file G4INCLNucleus.hh.

                                  {
      ParticleList const &inside = theStore->getParticles();
      for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
        if((*i)->isSigma()) return true;
      return false;
    }

decayInsideDeltas()

G4bool G4INCL::Nucleus::decayInsideDeltas

(

)

Force the decay of deltas inside the nucleus.

Returns

true if any delta was forced to decay.

Definition at line 399 of file G4INCLNucleus.cc.

                                    {
    /* If there is a pion potential, do nothing (deltas will be counted as
     * excitation energy).
     * If, however, the remnant is unphysical (Z<0 or Z>A), force the deltas to
     * decay and get rid of all the pions. In case you're wondering, you can
     * end up with Z<0 or Z>A if the remnant contains more pi- than protons or
     * more pi+ than neutrons, respectively.
     */
    const G4bool unphysicalRemnant = (theZ<0 || theZ>theA);
    if(thePotential->hasPionPotential() && !unphysicalRemnant)
      return false;
 
    // Build a list of deltas (avoid modifying the list you are iterating on).
    ParticleList const &inside = theStore->getParticles();
    ParticleList deltas;
    for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
      if((*i)->isDelta()) deltas.push_back((*i));
 
    // Loop over the deltas, make them decay
    for(ParticleIter i=deltas.begin(), e=deltas.end(); i!=e; ++i) {
      INCL_DEBUG("Decay inside delta particle:" << '\n'
          << (*i)->print() << '\n');
      // Create a forced-decay avatar. Note the last boolean parameter. Note
      // also that if the remnant is unphysical we more or less explicitly give
      // up energy conservation and CDPP by passing a NULL pointer for the
      // nucleus.
      IAvatar *decay;
      if(unphysicalRemnant) {
        INCL_WARN("Forcing delta decay inside an unphysical remnant (A=" << theA
             << ", Z=" << theZ << "). Might lead to energy-violation warnings."
             << '\n');
        decay = new DecayAvatar((*i), 0.0, NULL, true);
      } else
        decay = new DecayAvatar((*i), 0.0, this, true);
      FinalState *fs = decay->getFinalState();
 
      // The pion can be ejected only if we managed to satisfy energy
      // conservation and if pion emission does not lead to negative excitation
      // energies.
      if(fs->getValidity()==ValidFS) {
        // Apply the final state to the nucleus
        applyFinalState(fs);
      }
      delete fs;
      delete decay;
    }
 
    // If the remnant is unphysical, emit all the pions
    if(unphysicalRemnant) {
      INCL_DEBUG("Remnant is unphysical: Z=" << theZ << ", A=" << theA << ", emitting all the pions" << '\n');
      emitInsidePions();
    }
 
    return true;
  }

decayInsideStrangeParticles()

G4bool G4INCL::Nucleus::decayInsideStrangeParticles

(

)

Force the transformation of strange particles into a Lambda;.

Returns

true if any strange particles was forced to absorb.

Definition at line 455 of file G4INCLNucleus.cc.

                                              {
     
    /* Transform each strange particles into a lambda
     * Every Kaon (KPlus and KZero) are emited
     */
    const G4bool unphysicalRemnant = (theZ<0 || theZ>theA);
    if(unphysicalRemnant){
        emitInsideStrangeParticles();
        INCL_WARN("Remnant is unphysical: Z=" << theZ << ", A=" << theA << ", too much strange particles? -> all emit" << '\n');
        return false;
    }
 
    /* Build a list of particles with a strangeness == -1 except Lambda,
     * and two other one for proton and neutron
     */
    ParticleList const &inside = theStore->getParticles();
    ParticleList stranges;
    ParticleList protons;
    ParticleList neutrons;
    for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i){
        if((*i)->isSigma() || (*i)->isAntiKaon()) stranges.push_back((*i));
        else if((*i)->isNucleon() && (*i)->getZ() == 1) protons.push_back((*i));
        else if((*i)->isNucleon() && (*i)->getZ() == 0) neutrons.push_back((*i));
    }
    
    if((stranges.size() > protons.size()) || (stranges.size() > neutrons.size())){
        INCL_WARN("Remnant is unphysical: Nproton=" << protons.size() << ", Nneutron=" << neutrons.size() << ", Strange particles : " << stranges.size() <<  '\n');
        emitInsideStrangeParticles();
        return false;
    }
    
    // Loop over the strange particles, make them absorbe
    ParticleIter protonIter = protons.begin();
    ParticleIter neutronIter = neutrons.begin();
    for(ParticleIter i=stranges.begin(), e=stranges.end(); i!=e; ++i) {
      INCL_DEBUG("Absorbe inside strange particles:" << '\n'
          << (*i)->print() << '\n');
      IAvatar *decay;
      if((*i)->getType() == SigmaMinus){
          decay = new DecayAvatar((*protonIter), (*i), 0.0, this, true);
          ++protonIter;
      }
      else if((*i)->getType() == SigmaPlus){
          decay = new DecayAvatar((*neutronIter), (*i), 0.0, this, true);
          ++neutronIter;
      }
      else if(Random::shoot()*(protons.size() + neutrons.size()) < protons.size()){
          decay = new DecayAvatar((*protonIter), (*i), 0.0, this, true);
          ++protonIter;
      }
      else {
          decay = new DecayAvatar((*neutronIter), (*i), 0.0, this, true);
          ++neutronIter;
      }
      FinalState *fs = decay->getFinalState();
      applyFinalState(fs);
      delete fs;
      delete decay;
    }
 
    return true;
  }

decayMe()

G4bool G4INCL::Nucleus::decayMe

(

)

Force the phase-space decay of the Nucleus.

Only applied if Z==0 or N==0.

Returns

true if the nucleus was forced to decay.

Definition at line 696 of file G4INCLNucleus.cc.

                          {
    // Do the phase-space decay only if Z=0 or N=0
    if(theA<=1 || (theZ!=0 && (theA+theS)!=theZ))
      return false;
 
    ParticleList decayProducts = ClusterDecay::decay(this);
    for(ParticleIter j=decayProducts.begin(), e=decayProducts.end(); j!=e; ++j){
      (*j)->setBiasCollisionVector(this->getBiasCollisionVector());
      theStore->addToOutgoing(*j);
    }
    
    return true;
  }

decayOutgoingClusters()

G4bool G4INCL::Nucleus::decayOutgoingClusters

(

)

Force the decay of unstable outgoing clusters.

Returns

true if any cluster was forced to decay.

Definition at line 671 of file G4INCLNucleus.cc.

                                        {
    ParticleList const &out = theStore->getOutgoingParticles();
    ParticleList clusters;
    for(ParticleIter i=out.begin(), e=out.end(); i!=e; ++i) {
      if((*i)->isCluster()) clusters.push_back((*i));
    }
    if(clusters.empty()) return false;
 
    for(ParticleIter i=clusters.begin(), e=clusters.end(); i!=e; ++i) {
      Cluster *cluster = dynamic_cast<Cluster*>(*i); // Can't avoid using a cast here
// assert(cluster);
#ifdef INCLXX_IN_GEANT4_MODE
      if(!cluster)
        continue;
#endif
      cluster->deleteParticles(); // Don't need them
      ParticleList decayProducts = ClusterDecay::decay(cluster);
      for(ParticleIter j=decayProducts.begin(), end=decayProducts.end(); j!=end; ++j){
        (*j)->setBiasCollisionVector(cluster->getBiasCollisionVector());
        theStore->addToOutgoing(*j);
      }
    }
    return true;
  }

decayOutgoingDeltas()

G4bool G4INCL::Nucleus::decayOutgoingDeltas

(

)

Force the decay of outgoing deltas.

Returns

true if any delta was forced to decay.

Definition at line 346 of file G4INCLNucleus.cc.

                                      {
    ParticleList const &out = theStore->getOutgoingParticles();
    ParticleList deltas;
    for(ParticleIter i=out.begin(), e=out.end(); i!=e; ++i) {
      if((*i)->isDelta()) deltas.push_back((*i));
    }
    if(deltas.empty()) return false;
 
    for(ParticleIter i=deltas.begin(), e=deltas.end(); i!=e; ++i) {
      INCL_DEBUG("Decay outgoing delta particle:" << '\n'
          << (*i)->print() << '\n');
      const ThreeVector beta = -(*i)->boostVector();
      const G4double deltaMass = (*i)->getMass();
 
      // Set the delta momentum to zero and sample the decay in the CM frame.
      // This makes life simpler if we are using real particle masses.
      (*i)->setMomentum(ThreeVector());
      (*i)->setEnergy((*i)->getMass());
 
      // Use a DecayAvatar
      IAvatar *decay = new DecayAvatar((*i), 0.0, NULL);
      FinalState *fs = decay->getFinalState();
      Particle * const pion = fs->getCreatedParticles().front();
      Particle * const nucleon = fs->getModifiedParticles().front();
 
      // Adjust the decay momentum if we are using the real masses
      const G4double decayMomentum = KinematicsUtils::momentumInCM(deltaMass,
          nucleon->getTableMass(),
          pion->getTableMass());
      ThreeVector newMomentum = pion->getMomentum();
      newMomentum *= decayMomentum / newMomentum.mag();
 
      pion->setTableMass();
      pion->setMomentum(newMomentum);
      pion->adjustEnergyFromMomentum();
      pion->setEmissionTime(nucleon->getEmissionTime());
      pion->boost(beta);
      pion->setBiasCollisionVector(nucleon->getBiasCollisionVector());
 
      nucleon->setTableMass();
      nucleon->setMomentum(-newMomentum);
      nucleon->adjustEnergyFromMomentum();
      nucleon->boost(beta);
 
      theStore->addToOutgoing(pion);
 
      delete fs;
      delete decay;
    }
 
    return true;
  }

decayOutgoingNeutralKaon()

G4bool G4INCL::Nucleus::decayOutgoingNeutralKaon

(

)

Force the transformation of outgoing Neutral Kaon into propation eigenstate.

Returns

true if any kaon was forced to decay.

Definition at line 648 of file G4INCLNucleus.cc.

                                           {
        ParticleList const &out = theStore->getOutgoingParticles();
        ParticleList neutralkaon;
        for(ParticleIter i=out.begin(), e=out.end(); i!=e; ++i) {
            if((*i)->getType() == KZero  || (*i)->getType() == KZeroBar)  neutralkaon.push_back((*i));
        }
        if(neutralkaon.empty()) return false;
        
        for(ParticleIter i=neutralkaon.begin(), e=neutralkaon.end(); i!=e; ++i) {
            INCL_DEBUG("Transform outgoing neutral kaon:" << '\n'
                       << (*i)->print() << '\n');
            
            // Use a DecayAvatar
            IAvatar *decay = new DecayAvatar((*i), 0.0, NULL);
            FinalState *fs = decay->getFinalState();
            
            delete fs;
            delete decay;
        }
        
        return true;
    }

decayOutgoingPionResonances()

G4bool G4INCL::Nucleus::decayOutgoingPionResonances

(

G4double

timeThreshold

)

Force the decay of outgoing PionResonances (eta/omega).

Returns

true if any eta was forced to decay.

Definition at line 518 of file G4INCLNucleus.cc.

                                                                    {
        ParticleList const &out = theStore->getOutgoingParticles();
        ParticleList pionResonances;
        for(ParticleIter i=out.begin(), e=out.end(); i!=e; ++i) {
//            if((*i)->isEta() || (*i)->isOmega()) pionResonances.push_back((*i));
            if(((*i)->isEta() && timeThreshold > ParticleTable::getWidth(Eta)) || ((*i)->isOmega() && timeThreshold > ParticleTable::getWidth(Omega))) pionResonances.push_back((*i));
        }
        if(pionResonances.empty()) return false;
        
        for(ParticleIter i=pionResonances.begin(), e=pionResonances.end(); i!=e; ++i) {
            INCL_DEBUG("Decay outgoing pionResonances particle:" << '\n'
                       << (*i)->print() << '\n');
            const ThreeVector beta = -(*i)->boostVector();
            const G4double pionResonanceMass = (*i)->getMass();
            
            // Set the pionResonance momentum to zero and sample the decay in the CM frame.
            // This makes life simpler if we are using real particle masses.
            (*i)->setMomentum(ThreeVector());
            (*i)->setEnergy((*i)->getMass());
            
            // Use a DecayAvatar
            IAvatar *decay = new DecayAvatar((*i), 0.0, NULL);
            FinalState *fs = decay->getFinalState();
            
            Particle * const theModifiedParticle = fs->getModifiedParticles().front();
            ParticleList const &created = fs->getCreatedParticles();
            Particle * const theCreatedParticle1 = created.front();
                            
            if (created.size() == 1) {
                
                // Adjust the decay momentum if we are using the real masses
                const G4double decayMomentum = KinematicsUtils::momentumInCM(pionResonanceMass,theModifiedParticle->getTableMass(),theCreatedParticle1->getTableMass());
                ThreeVector newMomentum = theCreatedParticle1->getMomentum();
                newMomentum *= decayMomentum / newMomentum.mag();
                
                theCreatedParticle1->setTableMass();
                theCreatedParticle1->setMomentum(newMomentum);
                theCreatedParticle1->adjustEnergyFromMomentum();
                theCreatedParticle1->setEmissionTime((*i)->getEmissionTime());
                theCreatedParticle1->boost(beta);
                theCreatedParticle1->setBiasCollisionVector(theModifiedParticle->getBiasCollisionVector());
                
                theModifiedParticle->setTableMass();
                theModifiedParticle->setMomentum(-newMomentum);
                theModifiedParticle->adjustEnergyFromMomentum();
                theModifiedParticle->boost(beta);
                
                theStore->addToOutgoing(theCreatedParticle1);
            }
            else if (created.size() == 2) {
                Particle * const theCreatedParticle2 = created.back();
                
                theCreatedParticle1->boost(beta);
                theCreatedParticle1->setBiasCollisionVector(theModifiedParticle->getBiasCollisionVector());
                theCreatedParticle1->setEmissionTime((*i)->getEmissionTime());
                theCreatedParticle2->boost(beta);
                theCreatedParticle2->setBiasCollisionVector(theModifiedParticle->getBiasCollisionVector());
                theCreatedParticle2->setEmissionTime((*i)->getEmissionTime());
                theModifiedParticle->boost(beta);
                
                theStore->addToOutgoing(theCreatedParticle1);
                theStore->addToOutgoing(theCreatedParticle2);
            }
            else {
                INCL_ERROR("Wrong number (< 2) of created particles during the decay of a pion resonance");
            }
            delete fs;
            delete decay;
        }
        
        return true;
    }

decayOutgoingSigmaZero()

G4bool G4INCL::Nucleus::decayOutgoingSigmaZero

(

G4double

timeThreshold

)

Force the decay of outgoing Neutral Sigma.

Returns

true if any Sigma was forced to decay.

Definition at line 591 of file G4INCLNucleus.cc.

                                                               {
        ParticleList const &out = theStore->getOutgoingParticles();
        ParticleList neutralsigma;
        for(ParticleIter i=out.begin(), e=out.end(); i!=e; ++i) {
            if((*i)->getType() == SigmaZero && timeThreshold > ParticleTable::getWidth(SigmaZero))  neutralsigma.push_back((*i));
        }
        if(neutralsigma.empty()) return false;
        
        for(ParticleIter i=neutralsigma.begin(), e=neutralsigma.end(); i!=e; ++i) {
            INCL_DEBUG("Decay outgoing neutral sigma:" << '\n'
                       << (*i)->print() << '\n');
            const ThreeVector beta = -(*i)->boostVector();
            const G4double neutralsigmaMass = (*i)->getMass();
            
            // Set the neutral sigma momentum to zero and sample the decay in the CM frame.
            // This makes life simpler if we are using real particle masses.
            (*i)->setMomentum(ThreeVector());
            (*i)->setEnergy((*i)->getMass());
            
            // Use a DecayAvatar
            IAvatar *decay = new DecayAvatar((*i), 0.0, NULL);
            FinalState *fs = decay->getFinalState();
            
            Particle * const theModifiedParticle = fs->getModifiedParticles().front();
            ParticleList const &created = fs->getCreatedParticles();
            Particle * const theCreatedParticle = created.front();
                            
            if (created.size() == 1) {
                
                // Adjust the decay momentum if we are using the real masses
                const G4double decayMomentum = KinematicsUtils::momentumInCM(neutralsigmaMass,theModifiedParticle->getTableMass(),theCreatedParticle->getTableMass());
                ThreeVector newMomentum = theCreatedParticle->getMomentum();
                newMomentum *= decayMomentum / newMomentum.mag();
                
                theCreatedParticle->setTableMass();
                theCreatedParticle->setMomentum(newMomentum);
                theCreatedParticle->adjustEnergyFromMomentum();
                theCreatedParticle->boost(beta);
                theCreatedParticle->setBiasCollisionVector(theModifiedParticle->getBiasCollisionVector());
                
                theModifiedParticle->setTableMass();
                theModifiedParticle->setMomentum(-newMomentum);
                theModifiedParticle->adjustEnergyFromMomentum();
                theModifiedParticle->boost(beta);
                
                theStore->addToOutgoing(theCreatedParticle);
            }
            else {
                INCL_ERROR("Wrong number (!= 1) of created particles during the decay of a sigma zero");
            }
            delete fs;
            delete decay;
        }
        
        return true;
    }

deleteProjectileRemnant()

void G4INCL::Nucleus::deleteProjectileRemnant ( )

inline

Delete the projectile remnant.

Definition at line 525 of file G4INCLNucleus.hh.

                                   {
      delete theProjectileRemnant;
      theProjectileRemnant = NULL;
    }

Referenced by ~Nucleus().

emitInsideAnnihilationProducts()

G4bool G4INCL::Nucleus::emitInsideAnnihilationProducts

(

)

Force emission of all Antinucleon inside the nucleus.

Definition at line 923 of file G4INCLNucleus.cc.

                                                {
    /* Forcing annihilation of all Antinucleons in the nucleus and emission of the resulting particles.
    */
    INCL_DEBUG("Forcing annihilation of all Antinucleons and emission of all produced mesons in the nucleus." << '\n' );
    const G4double tinyEnergy = 0.1; // MeV
 
    ParticleList const &inside = theStore->getParticles();
    ParticleList antinucleons;
    ParticleList toEject; // mesons from antinucleon annihilations to be ejected
    G4double theNewZ=theZ;
 
    // Build a list of remaining antinucleons
    for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
      if((*i)->isAntiNucleon()) antinucleons.push_back((*i));
 
    // Loop over the antinucleons, build a list of mesons to be ejected
    for(ParticleIter i=antinucleons.begin(), e=antinucleons.end(); i!=e; ++i) {
      Particle * theAnnihilated = nullptr;
      G4double dist_NbarNuc = 1000.; //just a high random beginning
      G4double temp_dist = 0.;
      // Nucleon annihilated
      for (ParticleIter pnuc=inside.begin(), enuc=inside.end(); pnuc!=enuc;++pnuc){ 
        if ((*pnuc)->isNucleon()){
          temp_dist = ((*pnuc)->getPosition() - (*i)->getPosition()).mag(); // calculate distance between the antinucleon and nucleons in the nucleus
          if(temp_dist < dist_NbarNuc){ //obtain information of the last nucleon that was close enough
              dist_NbarNuc = temp_dist;
              theAnnihilated = (*pnuc);
          }
        }
      }
      // Annihilation (meson production)
      INCL_DEBUG("Forcing collision of the following particle :" <<'\n' << (*i)->print() << '\n' << theAnnihilated->print() << '\n' );
      theNewZ = theNewZ - (theAnnihilated->getZ() + ((*i)->getZ()));
      BinaryCollisionAvatar *collision = new BinaryCollisionAvatar(0.,9999.,this,theAnnihilated,(*i)); //Binary Collision Avatar to annihilate; XS=9999. means force annihilation
      FinalState *fs = collision->getFinalState();
      applyFinalState(fs);
      INCL_DEBUG("Forcing Emission of the resulting particle of the forced annihilation" << '\n');
      ParticleList modifiedparts = fs->getModifiedParticles();
      for(ParticleIter outs=modifiedparts.begin(), eouts=modifiedparts.end();outs!=eouts;outs++){
        toEject.push_back((*outs));
      }
      ParticleList const &created = fs->getCreatedParticles();
      if(created.size() !=0){
        for(ParticleIter out=created.begin(),eout=created.end();out!=eout;out++){
          toEject.push_back((*out));
        }
      }
      delete fs;
      delete collision;
    }
 
    // Loop over the mesons to be ejected
    for(ParticleIter iEject=toEject.begin(),eEject=toEject.end();iEject!=eEject;iEject++){ //Eject all produced mesons
      (*iEject)->setEmissionTime(theStore->getBook().getCurrentTime());
      G4double theQValueCorrection = (*iEject)->getEmissionQValueCorrection(theA,theZ,theS);
      G4double kineticEnergyOutside = (*iEject)->getKineticEnergy() - (*iEject)->getPotentialEnergy() + theQValueCorrection;
      (*iEject)->setTableMass();
      if(kineticEnergyOutside > 0.0)
        (*iEject)->setEnergy((*iEject)->getMass() + kineticEnergyOutside);
      else
        (*iEject)->setEnergy((*iEject)->getMass() + tinyEnergy);
      (*iEject)->adjustMomentumFromEnergy();
      (*iEject)->setPotentialEnergy(0.);
      theStore->particleHasBeenEjected(*iEject);
      theStore->addToOutgoing(*iEject);
    }
    
    theZ = theNewZ;
    return true;
  }

emitInsideAntilambda()

G4int G4INCL::Nucleus::emitInsideAntilambda

(

)

Force emission of all Antilambda.

Definition at line 836 of file G4INCLNucleus.cc.

                                      {
    /* Forcing emissions of all Antilambdas in the nucleus.
     * This probably violates energy conservation
     * (although the computation of the recoil kinematics
     * might sweep this under the carpet).
     */
    INCL_DEBUG("Forcing emissions of all antiLambda in the nucleus." << '\n');
 
    // Emit the Lambda with this kinetic energy
    const G4double tinyEnergy = 0.1; // MeV
 
    // Push out the emitted Lambda
    ParticleList const &inside = theStore->getParticles();
    ParticleList toEject;
    for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i) {
      if((*i)->isAntiLambda()) {
        Particle * const theAntiLambda = *i;
        INCL_DEBUG("Forcing emission of the following particle: "
                   << theAntiLambda->print() << '\n');
        theAntiLambda->setEmissionTime(theStore->getBook().getCurrentTime());
        // Correction for real masses
        const G4double theQValueCorrection = theAntiLambda->getEmissionQValueCorrection(theA,theZ,theS); // Does it work for strange particles? Should be check
        const G4double kineticEnergyOutside = theAntiLambda->getKineticEnergy() - theAntiLambda->getPotentialEnergy() + theQValueCorrection;
        theAntiLambda->setTableMass();
        if(kineticEnergyOutside > 0.0)
          theAntiLambda->setEnergy(theAntiLambda->getMass()+kineticEnergyOutside);
        else
          theAntiLambda->setEnergy(theAntiLambda->getMass()+tinyEnergy);
        theAntiLambda->adjustMomentumFromEnergy();
        theAntiLambda->setPotentialEnergy(0.);
        theA -= theAntiLambda->getA();
        theS -= theAntiLambda->getS();
        toEject.push_back(theAntiLambda);
      }
    }
    for(ParticleIter i=toEject.begin(), e=toEject.end(); i!=e; ++i) {
      theStore->particleHasBeenEjected(*i);
      theStore->addToOutgoing(*i);
      (*i)->setParticleBias(Particle::getTotalBias());
    }
    return (G4int)toEject.size();
  }

emitInsideKaon()

G4bool G4INCL::Nucleus::emitInsideKaon

(

)

Force emission of all Kaon inside the nucleus.

Definition at line 879 of file G4INCLNucleus.cc.

                                 {
    /* Forcing emissions of all Kaon (not antiKaons) in the nucleus.
     * This probably violates energy conservation
     * (although the computation of the recoil kinematics
     * might sweep this under the carpet).
     */
    INCL_DEBUG("Forcing emissions of all Kaon in the nucleus." << '\n');
 
    // Emit the Kaon with this kinetic energy (not supposed to append
    const G4double tinyEnergy = 0.1; // MeV
 
    // Push out the emitted kaon
    ParticleList const &inside = theStore->getParticles();
    ParticleList toEject;
    for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i) {
      if((*i)->isKaon()) {
        Particle * const theKaon = *i;
        INCL_DEBUG("Forcing emission of the following particle: "
                   << theKaon->print() << '\n');
        theKaon->setEmissionTime(theStore->getBook().getCurrentTime());
        // Correction for real masses
        const G4double theQValueCorrection = theKaon->getEmissionQValueCorrection(theA,theZ,theS);
        const G4double kineticEnergyOutside = theKaon->getKineticEnergy() - theKaon->getPotentialEnergy() + theQValueCorrection;
        theKaon->setTableMass();
        if(kineticEnergyOutside > 0.0)
          theKaon->setEnergy(theKaon->getMass()+kineticEnergyOutside);
        else
          theKaon->setEnergy(theKaon->getMass()+tinyEnergy);
        theKaon->adjustMomentumFromEnergy();
        theKaon->setPotentialEnergy(0.);
        theZ -= theKaon->getZ();
        theS -= theKaon->getS();
        toEject.push_back(theKaon);
      }
    }
    for(ParticleIter i=toEject.begin(), e=toEject.end(); i!=e; ++i) {
      theStore->particleHasBeenEjected(*i);
      theStore->addToOutgoing(*i);
      (*i)->setParticleBias(Particle::getTotalBias());
    }
    theNKaon -= 1;
    return toEject.size() != 0;
  }

emitInsideLambda()

G4int G4INCL::Nucleus::emitInsideLambda

(

)

Force emission of all Lambda (desexitation code with strangeness not implanted yet).

Definition at line 793 of file G4INCLNucleus.cc.

                                  {
    /* Forcing emissions of all Lambda in the nucleus.
     * This probably violates energy conservation
     * (although the computation of the recoil kinematics
     * might sweep this under the carpet).
     */
    INCL_DEBUG("Forcing emissions of all Lambda in the nucleus." << '\n');
 
    // Emit the Lambda with this kinetic energy
    const G4double tinyEnergy = 0.1; // MeV
 
    // Push out the emitted Lambda
    ParticleList const &inside = theStore->getParticles();
    ParticleList toEject;
    for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i) {
      if((*i)->isLambda()) {
        Particle * const theLambda = *i;
        INCL_DEBUG("Forcing emission of the following particle: "
                   << theLambda->print() << '\n');
        theLambda->setEmissionTime(theStore->getBook().getCurrentTime());
        // Correction for real masses
        const G4double theQValueCorrection = theLambda->getEmissionQValueCorrection(theA,theZ,theS); // Does it work for strange particles? Should be check
        const G4double kineticEnergyOutside = theLambda->getKineticEnergy() - theLambda->getPotentialEnergy() + theQValueCorrection;
        theLambda->setTableMass();
        if(kineticEnergyOutside > 0.0)
          theLambda->setEnergy(theLambda->getMass()+kineticEnergyOutside);
        else
          theLambda->setEnergy(theLambda->getMass()+tinyEnergy);
        theLambda->adjustMomentumFromEnergy();
        theLambda->setPotentialEnergy(0.);
        theA -= theLambda->getA();
        theS -= theLambda->getS();
        toEject.push_back(theLambda);
      }
    }
    for(ParticleIter i=toEject.begin(), e=toEject.end(); i!=e; ++i) {
      theStore->particleHasBeenEjected(*i);
      theStore->addToOutgoing(*i);
      (*i)->setParticleBias(Particle::getTotalBias());
    }
    return (G4int)toEject.size();
  }

emitInsidePions()

void G4INCL::Nucleus::emitInsidePions

(

)

Force emission of all pions inside the nucleus.

Definition at line 710 of file G4INCLNucleus.cc.

                                {
    /* Forcing emissions of all pions in the nucleus. This probably violates
     * energy conservation (although the computation of the recoil kinematics
     * might sweep this under the carpet).
     */
    INCL_WARN("Forcing emissions of all pions in the nucleus." << '\n');
 
    // Emit the pions with this kinetic energy
    const G4double tinyPionEnergy = 0.1; // MeV
 
    // Push out the emitted pions
    ParticleList const &inside = theStore->getParticles();
    ParticleList toEject;
    for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i) {
      if((*i)->isPion()) {
        Particle * const thePion = *i;
        INCL_DEBUG("Forcing emission of the following particle: "
                   << thePion->print() << '\n');
        thePion->setEmissionTime(theStore->getBook().getCurrentTime());
        // Correction for real masses
        const G4double theQValueCorrection = thePion->getEmissionQValueCorrection(theA,theZ,theS);
        const G4double kineticEnergyOutside = thePion->getKineticEnergy() - thePion->getPotentialEnergy() + theQValueCorrection;
        thePion->setTableMass();
        if(kineticEnergyOutside > 0.0)
          thePion->setEnergy(thePion->getMass()+kineticEnergyOutside);
        else
          thePion->setEnergy(thePion->getMass()+tinyPionEnergy);
        thePion->adjustMomentumFromEnergy();
        thePion->setPotentialEnergy(0.);
        theZ -= thePion->getZ();
        toEject.push_back(thePion);
      }
    }
    for(ParticleIter i=toEject.begin(), e=toEject.end(); i!=e; ++i) {
      theStore->particleHasBeenEjected(*i);
      theStore->addToOutgoing(*i);
      (*i)->setParticleBias(Particle::getTotalBias());
    }
  }

Referenced by computeRecoilKinematics(), and decayInsideDeltas().

emitInsideStrangeParticles()

void G4INCL::Nucleus::emitInsideStrangeParticles

(

)

Force emission of all strange particles inside the nucleus.

Definition at line 750 of file G4INCLNucleus.cc.

                                           {
    /* Forcing emissions of Sigmas and antiKaons.
     * This probably violates energy conservation
     * (although the computation of the recoil kinematics
     * might sweep this under the carpet).
     */
    INCL_DEBUG("Forcing emissions of all strange particles in the nucleus." << '\n');
 
    // Emit the strange particles with this kinetic energy
    const G4double tinyEnergy = 0.1; // MeV
 
    // Push out the emitted strange particles
    ParticleList const &inside = theStore->getParticles();
    ParticleList toEject;
    for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i) {
      if((*i)->isSigma() || (*i)->isAntiKaon()) {
        Particle * const theParticle = *i;
        INCL_DEBUG("Forcing emission of the following particle: "
                   << theParticle->print() << '\n');
        theParticle->setEmissionTime(theStore->getBook().getCurrentTime());
        // Correction for real masses
        const G4double theQValueCorrection = theParticle->getEmissionQValueCorrection(theA,theZ,theS); // Does it work for strange particles? should be check
        const G4double kineticEnergyOutside = theParticle->getKineticEnergy() - theParticle->getPotentialEnergy() + theQValueCorrection;
        theParticle->setTableMass();
        if(kineticEnergyOutside > 0.0)
          theParticle->setEnergy(theParticle->getMass()+kineticEnergyOutside);
        else
          theParticle->setEnergy(theParticle->getMass()+tinyEnergy);
        theParticle->adjustMomentumFromEnergy();
        theParticle->setPotentialEnergy(0.);
        theA -= theParticle->getA();
        theZ -= theParticle->getZ();
        theS -= theParticle->getS();
        toEject.push_back(theParticle);
      }
    }
    for(ParticleIter i=toEject.begin(), e=toEject.end(); i!=e; ++i) {
      theStore->particleHasBeenEjected(*i);
      theStore->addToOutgoing(*i);
      (*i)->setParticleBias(Particle::getTotalBias());
    }
  }

Referenced by decayInsideStrangeParticles().

fillEventInfo()

void G4INCL::Nucleus::fillEventInfo

(

EventInfo *

eventInfo

)

Fill the event info which contains INCL output data

Definition at line 1164 of file G4INCLNucleus.cc.

                                                  {
    eventInfo->nParticles = 0;
    G4bool isNucleonAbsorption = false;
    G4bool isPionAbsorption = false;
    // It is possible to have pion absorption event only if the
    // projectile is pion.
    if(eventInfo->projectileType == PiPlus ||
       eventInfo->projectileType == PiMinus ||
       eventInfo->projectileType == PiZero) {
      isPionAbsorption = true;
    }
 
    // Forced CN
    eventInfo->forcedCompoundNucleus = tryCN;
 
    // Outgoing particles
    ParticleList const &outgoingParticles = getStore()->getOutgoingParticles();
 
    // Check if we have a nucleon absorption event: nucleon projectile
    // and no ejected particles.
    if(outgoingParticles.size() == 0 &&
       (eventInfo->projectileType == Proton ||
    eventInfo->projectileType == Neutron)) {
      isNucleonAbsorption = true;
    }
 
    // Reset the remnant counter
    eventInfo->nRemnants = 0;
    eventInfo->history.clear();
 
    for(ParticleIter i=outgoingParticles.begin(), e=outgoingParticles.end(); i!=e; ++i ) {
      // We have a pion absorption event only if the projectile is
      // pion and there are no ejected pions.
      if(isPionAbsorption) {
        if((*i)->isPion()) {
          isPionAbsorption = false;
        }
      }
      
      eventInfo->ParticleBias[eventInfo->nParticles] = (*i)->getParticleBias();
      
#ifdef INCLXX_IN_GEANT4_MODE
      eventInfo->A[eventInfo->nParticles] = (G4INCL::Short_t)(*i)->getA();
      eventInfo->Z[eventInfo->nParticles] = (G4INCL::Short_t)(*i)->getZ();
      eventInfo->S[eventInfo->nParticles] = (G4INCL::Short_t)(*i)->getS();
#else
      eventInfo->A[eventInfo->nParticles] = (Short_t)(*i)->getA();
      eventInfo->Z[eventInfo->nParticles] = (Short_t)(*i)->getZ();
      eventInfo->S[eventInfo->nParticles] = (Short_t)(*i)->getS();
#endif 
      eventInfo->emissionTime[eventInfo->nParticles] = (*i)->getEmissionTime();
      eventInfo->EKin[eventInfo->nParticles] = (*i)->getKineticEnergy();
      ThreeVector mom = (*i)->getMomentum();
      eventInfo->px[eventInfo->nParticles] = mom.getX();
      eventInfo->py[eventInfo->nParticles] = mom.getY();
      eventInfo->pz[eventInfo->nParticles] = mom.getZ();
      eventInfo->theta[eventInfo->nParticles] = Math::toDegrees(mom.theta());
      eventInfo->phi[eventInfo->nParticles] = Math::toDegrees(mom.phi());
      eventInfo->origin[eventInfo->nParticles] = -1;
#ifdef INCLXX_IN_GEANT4_MODE
      eventInfo->parentResonancePDGCode[eventInfo->nParticles] = (*i)->getParentResonancePDGCode();
      eventInfo->parentResonanceID[eventInfo->nParticles] = (*i)->getParentResonanceID();
#endif 
      eventInfo->history.push_back("");
      if ((*i)->getType() != Composite && (*i)->getType() != antiComposite ) {
        ParticleSpecies pt((*i)->getType());
        eventInfo->PDGCode[eventInfo->nParticles] = pt.getPDGCode();
      }
      else if((*i)->getType() == Composite) {
        ParticleSpecies pt((*i)->getA(), (*i)->getZ(), (*i)->getS());
        eventInfo->PDGCode[eventInfo->nParticles] = pt.getPDGCode();
      }
      else if((*i)->getType() == antiComposite) {
        ParticleSpecies pt(-(*i)->getA(), -(*i)->getZ(), (*i)->getS());
        eventInfo->PDGCode[eventInfo->nParticles] = pt.getPDGCode();
      }
      eventInfo->nParticles++;
    }
    eventInfo->nucleonAbsorption = isNucleonAbsorption;
    eventInfo->pionAbsorption = isPionAbsorption;
    eventInfo->nCascadeParticles = eventInfo->nParticles;
 
    // Projectile-like remnant characteristics
    if(theProjectileRemnant && (theProjectileRemnant->getA()>0 || theProjectileRemnant->getA()<0)) {
#ifdef INCLXX_IN_GEANT4_MODE
      eventInfo->ARem[eventInfo->nRemnants] = (G4INCL::Short_t)theProjectileRemnant->getA();
      eventInfo->ZRem[eventInfo->nRemnants] = (G4INCL::Short_t)theProjectileRemnant->getZ();
      eventInfo->SRem[eventInfo->nRemnants] = (G4INCL::Short_t)theProjectileRemnant->getS();
#else
      eventInfo->ARem[eventInfo->nRemnants] = (Short_t)theProjectileRemnant->getA();
      eventInfo->ZRem[eventInfo->nRemnants] = (Short_t)theProjectileRemnant->getZ();
      eventInfo->SRem[eventInfo->nRemnants] = (Short_t)theProjectileRemnant->getS();
#endif 
      G4double eStar = theProjectileRemnant->getExcitationEnergy();
      if(std::abs(eStar)<1E-10)
        eStar = 0.0; // blame rounding and set the excitation energy to zero
      eventInfo->EStarRem[eventInfo->nRemnants] = eStar;
      if(eventInfo->EStarRem[eventInfo->nRemnants]<0.) {
    INCL_WARN("Negative excitation energy in projectile-like remnant! EStarRem = " << eventInfo->EStarRem[eventInfo->nRemnants] << '\n');
      }
      const ThreeVector &spin = theProjectileRemnant->getSpin();
      if(eventInfo->ARem[eventInfo->nRemnants]%2==0) { // even-A nucleus
    eventInfo->JRem[eventInfo->nRemnants] = (G4int) (spin.mag()/PhysicalConstants::hc + 0.5);
      } else { // odd-A nucleus
    eventInfo->JRem[eventInfo->nRemnants] = ((G4int) (spin.mag()/PhysicalConstants::hc)) + 0.5;
      }
      eventInfo->EKinRem[eventInfo->nRemnants] = theProjectileRemnant->getKineticEnergy();
      const ThreeVector &mom = theProjectileRemnant->getMomentum();
      eventInfo->pxRem[eventInfo->nRemnants] = mom.getX();
      eventInfo->pyRem[eventInfo->nRemnants] = mom.getY();
      eventInfo->pzRem[eventInfo->nRemnants] = mom.getZ();
      eventInfo->jxRem[eventInfo->nRemnants] = spin.getX() / PhysicalConstants::hc;
      eventInfo->jyRem[eventInfo->nRemnants] = spin.getY() / PhysicalConstants::hc;
      eventInfo->jzRem[eventInfo->nRemnants] = spin.getZ() / PhysicalConstants::hc;
      eventInfo->thetaRem[eventInfo->nRemnants] = Math::toDegrees(mom.theta());
      eventInfo->phiRem[eventInfo->nRemnants] = Math::toDegrees(mom.phi());
      eventInfo->nRemnants++;
    }
 
    // Target-like remnant characteristics
    if(hasRemnant()) {
#ifdef INCLXX_IN_GEANT4_MODE
      eventInfo->ARem[eventInfo->nRemnants] = (G4INCL::Short_t)getA();
      eventInfo->ZRem[eventInfo->nRemnants] = (G4INCL::Short_t)getZ();
      eventInfo->SRem[eventInfo->nRemnants] = (G4INCL::Short_t)getS();
#else
      eventInfo->ARem[eventInfo->nRemnants] = (Short_t)getA();
      eventInfo->ZRem[eventInfo->nRemnants] = (Short_t)getZ();
      eventInfo->SRem[eventInfo->nRemnants] = (Short_t)getS();
#endif 
      eventInfo->EStarRem[eventInfo->nRemnants] = getExcitationEnergy();
      if(eventInfo->EStarRem[eventInfo->nRemnants]<0.) {
    INCL_WARN("Negative excitation energy in target-like remnant! EStarRem = " << eventInfo->EStarRem[eventInfo->nRemnants] << " eventNumber=" << eventInfo->eventNumber << '\n');
      }
      const ThreeVector &spin = getSpin();
      if(eventInfo->ARem[eventInfo->nRemnants]%2==0) { // even-A nucleus
    eventInfo->JRem[eventInfo->nRemnants] = (G4int) (spin.mag()/PhysicalConstants::hc + 0.5);
      } else { // odd-A nucleus
    eventInfo->JRem[eventInfo->nRemnants] = ((G4int) (spin.mag()/PhysicalConstants::hc)) + 0.5;
      }
      eventInfo->EKinRem[eventInfo->nRemnants] = getKineticEnergy();
      const ThreeVector &mom = getMomentum();
      eventInfo->pxRem[eventInfo->nRemnants] = mom.getX();
      eventInfo->pyRem[eventInfo->nRemnants] = mom.getY();
      eventInfo->pzRem[eventInfo->nRemnants] = mom.getZ();
      eventInfo->jxRem[eventInfo->nRemnants] = spin.getX() / PhysicalConstants::hc;
      eventInfo->jyRem[eventInfo->nRemnants] = spin.getY() / PhysicalConstants::hc;
      eventInfo->jzRem[eventInfo->nRemnants] = spin.getZ() / PhysicalConstants::hc;
      eventInfo->thetaRem[eventInfo->nRemnants] = Math::toDegrees(mom.theta());
      eventInfo->phiRem[eventInfo->nRemnants] = Math::toDegrees(mom.phi());
      eventInfo->nRemnants++;
    }
 
    // Global counters, flags, etc.
    Book const &theBook = theStore->getBook();
    eventInfo->nCollisions = theBook.getAcceptedCollisions();
    eventInfo->nBlockedCollisions = theBook.getBlockedCollisions();
    eventInfo->nDecays = theBook.getAcceptedDecays();
    eventInfo->nBlockedDecays = theBook.getBlockedDecays();
    eventInfo->firstCollisionTime = theBook.getFirstCollisionTime();
    eventInfo->firstCollisionXSec = theBook.getFirstCollisionXSec();
    eventInfo->firstCollisionSpectatorPosition = theBook.getFirstCollisionSpectatorPosition();
    eventInfo->firstCollisionSpectatorMomentum = theBook.getFirstCollisionSpectatorMomentum();
    eventInfo->firstCollisionIsElastic = theBook.getFirstCollisionIsElastic();
    eventInfo->nReflectionAvatars = theBook.getAvatars(SurfaceAvatarType);
    eventInfo->nCollisionAvatars = theBook.getAvatars(CollisionAvatarType);
    eventInfo->nDecayAvatars = theBook.getAvatars(DecayAvatarType);
    eventInfo->nEnergyViolationInteraction = theBook.getEnergyViolationInteraction();
    eventInfo->nSrcPairs = theBook.getSrcPairs();
    eventInfo->nSrcCollisions = theBook.getAcceptedSrcCollisions();
  }

finalizeProjectileRemnant()

void G4INCL::Nucleus::finalizeProjectileRemnant

(

const G4double

emissionTime

)

Finalise the projectile remnant.

Complete the treatment of the projectile remnant. If it contains nucleons, assign its excitation energy and spin. Move stuff to the outgoing list, if appropriate.

Parameters

emissionTime

the emission time of the projectile remnant

Definition at line 1426 of file G4INCLNucleus.cc.

                                                                       {
    // Deal with the projectile remnant
    const G4int prA = theProjectileRemnant->getA();
    if(prA>=1 || prA<=-1) {
      // Set the mass
      const G4double aMass = theProjectileRemnant->getInvariantMass();
      theProjectileRemnant->setMass(aMass);
 
      // Compute the excitation energy from the invariant 
      G4double anExcitationEnergy;
      if(prA>=1)
       anExcitationEnergy = aMass - ParticleTable::getTableMass(prA, theProjectileRemnant->getZ(), theProjectileRemnant->getS());
      else 
       anExcitationEnergy = aMass - ParticleTable::getTableMass(-prA, -(theProjectileRemnant->getZ()), theProjectileRemnant->getS()); 
 
      // Set the excitation energy
      theProjectileRemnant->setExcitationEnergy(anExcitationEnergy);
 
      // No spin!
      theProjectileRemnant->setSpin(ThreeVector());
 
      // Set the emission time
      theProjectileRemnant->setEmissionTime(anEmissionTime);
    }
  }

getAnnihilationType()

AnnihilationType G4INCL::Nucleus::getAnnihilationType ( ) const

inline

Getter for theAnnihilationType.

Definition at line 559 of file G4INCLNucleus.hh.

{ return theAType; }; //D

getAType()

AnnihilationType G4INCL::Nucleus::getAType

(

)

const

Definition at line 134 of file G4INCLNucleus.cc.

                                           {
    return theAType;
  }

getConservationBalance()

Nucleus::ConservationBalance G4INCL::Nucleus::getConservationBalance	(	EventInfo const &	theEventInfo,
		const G4bool	afterRecoil ) const

Compute charge, mass, energy and momentum balance.

Definition at line 1338 of file G4INCLNucleus.cc.

                                                                                                                          {
    ConservationBalance theBalance;
    // Initialise balance variables with the incoming values
    INCL_DEBUG("theEventInfo " << theEventInfo.Zt << "   " << theEventInfo.At << '\n');
    theBalance.Z = theEventInfo.Zp + theEventInfo.Zt;
    theBalance.A = theEventInfo.Ap + theEventInfo.At;
    theBalance.S = theEventInfo.Sp + theEventInfo.St;
    INCL_DEBUG("theBalance Z and A " << theBalance.Z << "   " << theBalance.A << '\n');
    theBalance.energy = getInitialEnergy() + getSrcInternalEnergy();
    theBalance.momentum = getIncomingMomentum();
 
    // Process outgoing particles
    ParticleList const &outgoingParticles = theStore->getOutgoingParticles();
    for(ParticleIter i=outgoingParticles.begin(), e=outgoingParticles.end(); i!=e; ++i ) {
      theBalance.Z -= (*i)->getZ();
      theBalance.A -= (*i)->getA();
      theBalance.S -= (*i)->getS();
      // For outgoing clusters, the total energy automatically includes the
      // excitation energy
      theBalance.energy -= (*i)->getEnergy(); // Note that outgoing particles should have the real mass
      theBalance.momentum -= (*i)->getMomentum();
    }
 
    // Projectile-like remnant contribution, if present
    if(theProjectileRemnant && (theProjectileRemnant->getA()>0 || theProjectileRemnant->getA()<0)) {
      theBalance.Z -= theProjectileRemnant->getZ();
      theBalance.A -= theProjectileRemnant->getA();
      theBalance.S -= theProjectileRemnant->getS();
      if(theProjectileRemnant->getA()>0)
        theBalance.energy -= ParticleTable::getTableMass(theProjectileRemnant->getA(),theProjectileRemnant->getZ(),theProjectileRemnant->getS()) + theProjectileRemnant->getExcitationEnergy();
      else if(theProjectileRemnant->getA()<0)
        theBalance.energy -= ParticleTable::getTableMass(-(theProjectileRemnant->getA()),-(theProjectileRemnant->getZ()),theProjectileRemnant->getS()) + theProjectileRemnant->getExcitationEnergy();
      theBalance.energy -= theProjectileRemnant->getKineticEnergy();
      theBalance.momentum -= theProjectileRemnant->getMomentum();
    }
 
    //Missed particle contribution, for anticomposite model B
    ParticleList const & missedParticles = theStore->getMissedParticles();
    for(ParticleIter i=missedParticles.begin(), e=missedParticles.end(); i!=e;++i){
      theBalance.Z -= (*i)->getZ();
      theBalance.A -= (*i)->getA();
      theBalance.S -= (*i)->getS();
      theBalance.energy -= (*i)->getEnergy();
      //theBalance.momentum -= (*i)->getMomentum();
    }
 
    // Target-like remnant contribution, if present
    if(hasRemnant()) {
      theBalance.Z -= getZ();
      theBalance.A -= getA();
      theBalance.S -= getS();
      theBalance.energy -= ParticleTable::getTableMass(getA(),getZ(),getS()) +
        getExcitationEnergy();
      if(afterRecoil)
        theBalance.energy -= getKineticEnergy();
      theBalance.momentum -= getMomentum();
      
    Book const &theBook = theStore->getBook();
      
    if (getExcitationEnergy() < 0. && theBook.getAcceptedSrcCollisions()) {
      INCL_DEBUG("excitation energy negative and afterrecoil "
                 << afterRecoil << " " << getExcitationEnergy()
                 << " eventNumber=" << theEventInfo.eventNumber << " "
                 << getInitialInternalEnergy() << '\n');
      INCL_DEBUG("excitation energy negative and afterrecoil "
                 << getInitialInternalEnergy() << " " << getSrcInternalEnergy()
                 << " " << initialEnergy << '\n');
    }
 
    if (theBook.getAcceptedSrcCollisions() && !afterRecoil) {
      INCL_DEBUG("excitation energy " << getExcitationEnergy()
                                      << " and afterrecoil 1 , kinetic energy ="
                                      << getKineticEnergy() << ", eventNumber="
                                      << theEventInfo.eventNumber << '\n');
    }
    }
 
    return theBalance;
  }

getDensity()

NuclearDensity const * G4INCL::Nucleus::getDensity ( ) const

inline

Getter for theDensity.

Definition at line 553 of file G4INCLNucleus.hh.

{ return theDensity; };

getExcitationEnergy()

G4double G4INCL::Nucleus::getExcitationEnergy ( ) const

inline

Get the excitation energy of the nucleus.

Method computeRecoilKinematics() should be called first.

Definition at line 328 of file G4INCLNucleus.hh.

{ return theExcitationEnergy; }

Referenced by fillEventInfo(), and getConservationBalance().

getIncomingAngularMomentum()

const ThreeVector & G4INCL::Nucleus::getIncomingAngularMomentum ( ) const

inline

Get the incoming angular-momentum vector.

Definition at line 306 of file G4INCLNucleus.hh.

{ return incomingAngularMomentum; }

getIncomingMomentum()

const ThreeVector & G4INCL::Nucleus::getIncomingMomentum ( ) const

inline

Get the incoming momentum vector.

Definition at line 314 of file G4INCLNucleus.hh.

                                                   {
      return incomingMomentum;
    }

Referenced by getConservationBalance().

getInitialA()

G4int G4INCL::Nucleus::getInitialA ( ) const

inline

Definition at line 126 of file G4INCLNucleus.hh.

{ return theInitialA; };

getInitialEnergy()

G4double G4INCL::Nucleus::getInitialEnergy ( ) const

inline

Get the initial energy.

Definition at line 322 of file G4INCLNucleus.hh.

{ return initialEnergy; }

Referenced by getConservationBalance().

getInitialInternalEnergy()

G4double G4INCL::Nucleus::getInitialInternalEnergy ( ) const

inline

Definition at line 434 of file G4INCLNucleus.hh.

{ return initialInternalEnergy; };

Referenced by getConservationBalance().

getInitialS()

G4int G4INCL::Nucleus::getInitialS ( ) const

inline

Definition at line 128 of file G4INCLNucleus.hh.

{ return theInitialS; };

getInitialZ()

G4int G4INCL::Nucleus::getInitialZ ( ) const

inline

Definition at line 127 of file G4INCLNucleus.hh.

{ return theInitialZ; };

getNumberOfEnteringantiNeutrons()

G4int G4INCL::Nucleus::getNumberOfEnteringantiNeutrons ( ) const

inline

Definition at line 142 of file G4INCLNucleus.hh.

{ return theNantineutronInitial; };

getNumberOfEnteringantiProtons()

G4int G4INCL::Nucleus::getNumberOfEnteringantiProtons ( ) const

inline

Definition at line 141 of file G4INCLNucleus.hh.

{ return theNantiprotonInitial; };

getNumberOfEnteringKaons()

G4int G4INCL::Nucleus::getNumberOfEnteringKaons ( ) const

inline

Definition at line 140 of file G4INCLNucleus.hh.

{ return theNkaonplusInitial+theNkaonminusInitial; };

getNumberOfEnteringNeutrons()

G4int G4INCL::Nucleus::getNumberOfEnteringNeutrons ( ) const

inline

Definition at line 138 of file G4INCLNucleus.hh.

{ return theNnInitial; };

getNumberOfEnteringPions()

G4int G4INCL::Nucleus::getNumberOfEnteringPions ( ) const

inline

Definition at line 139 of file G4INCLNucleus.hh.

{ return theNpionplusInitial+theNpionminusInitial; };

getNumberOfEnteringProtons()

G4int G4INCL::Nucleus::getNumberOfEnteringProtons ( ) const

inline

Definition at line 137 of file G4INCLNucleus.hh.

{ return theNpInitial; };

getPotential()

NuclearPotential::INuclearPotential const * G4INCL::Nucleus::getPotential ( ) const

inline

Getter for thePotential.

Definition at line 556 of file G4INCLNucleus.hh.

{ return thePotential; };

getProjectileRemnant()

ProjectileRemnant * G4INCL::Nucleus::getProjectileRemnant ( ) const

inline

Get the projectile remnant.

Definition at line 522 of file G4INCLNucleus.hh.

{ return theProjectileRemnant; }

getSrcInternalEnergy()

G4double G4INCL::Nucleus::getSrcInternalEnergy ( ) const

inline

Definition at line 417 of file G4INCLNucleus.hh.

                                          {
      return srcInternalEnergy;
    }      

Referenced by getConservationBalance().

getStore()

Store * G4INCL::Nucleus::getStore ( ) const

inline

Definition at line 428 of file G4INCLNucleus.hh.

{return theStore; };

Referenced by fillEventInfo().

getSurfaceRadius()

G4double G4INCL::Nucleus::getSurfaceRadius ( Particle const *const particle ) const

inline

Get the maximum allowed radius for a given particle.

Calls the NuclearDensity::getMaxRFromP() method for nucleons and deltas, and the NuclearDensity::getTrasmissionRadius() method for pions.

Parameters

particle

pointer to a particle

Returns

surface radius

Definition at line 485 of file G4INCLNucleus.hh.

                                                                     {
      if(particle->isNucleon() || particle->isLambda() || particle->isResonance()){
        const G4double pr = particle->getReflectionMomentum()/thePotential->getFermiMomentum(particle);
        if(pr>=1.)
          return getUniverseRadius();
        else
          return theDensity->getMaxRFromP(particle->getType(), pr);
        }
      else {
        // Temporarily set RPION = RMAX
        return getUniverseRadius();
        //return 0.5*(theDensity->getTransmissionRadius(particle)+getUniverseRadius());
      }
    }

getTransmissionBarrier()

G4double G4INCL::Nucleus::getTransmissionBarrier ( Particle const *const p )

inline

Get the transmission barrier.

Definition at line 456 of file G4INCLNucleus.hh.

                                                              {
      const G4double theTransmissionRadius = theDensity->getTransmissionRadius(p);
      const G4double theParticleZ = p->getZ();
      return PhysicalConstants::eSquared*(theZ-theParticleZ)*theParticleZ/theTransmissionRadius;
    }

getTryCompoundNucleus()

G4bool G4INCL::Nucleus::getTryCompoundNucleus ( )

inline

Definition at line 453 of file G4INCLNucleus.hh.

{ return tryCN; }

getUniverseRadius()

G4double G4INCL::Nucleus::getUniverseRadius ( ) const

inline

Getter for theUniverseRadius.

Definition at line 501 of file G4INCLNucleus.hh.

{ return theUniverseRadius; }

Referenced by getSurfaceRadius().

hasRemnant()

G4bool G4INCL::Nucleus::hasRemnant ( ) const

inline

Does the nucleus give a cascade remnant?

To be called after computeRecoilKinematics().

Definition at line 446 of file G4INCLNucleus.hh.

{ return remnant; }

Referenced by fillEventInfo(), and getConservationBalance().

initializeParticles()

void G4INCL::Nucleus::initializeParticles ( )

virtual

Call the Cluster method to generate the initial distribution of particles. At the beginning all particles are assigned as spectators.

Reimplemented from G4INCL::Cluster.

Definition at line 142 of file G4INCLNucleus.cc.

                                    {
    // Reset the variables connected with the projectile remnant
    delete theProjectileRemnant;
    theProjectileRemnant = NULL;
    Cluster::initializeParticles();
 
    for(ParticleIter i=particles.begin(), e=particles.end(); i!=e; ++i) {
      updatePotentialEnergy(*i);
    }
    theStore->add(particles);
    particles.clear();
    initialInternalEnergy = computeTotalEnergy();
    initialCenterOfMass = thePosition;
  }

insertParticle()

void G4INCL::Nucleus::insertParticle ( Particle * p )

inline

Insert a new particle (e.g. a projectile) in the nucleus.

Definition at line 88 of file G4INCLNucleus.hh.

                                     {
      theZ += p->getZ();
      theA += p->getA();
      theS += p->getS();
      theStore->particleHasEntered(p);
      if(p->isNucleon()) {
        theNpInitial += Math::heaviside(ParticleTable::getIsospin(p->getType()));
        theNnInitial += Math::heaviside(-ParticleTable::getIsospin(p->getType()));
      }
      if(p->isLambda())
        theNlInitial++;
      if(p->getType() == SigmaPlus)
        theNSpInitial++;
      if(p->getType() == SigmaZero)
        theNSzInitial++;
      if(p->getType() == SigmaMinus)
        theNSmInitial++;
      
      if(p->isPion()) {
        theNpionplusInitial += Math::heaviside(ParticleTable::getIsospin(p->getType()));
        theNpionminusInitial += Math::heaviside(-ParticleTable::getIsospin(p->getType()));
      }
      if(p->isKaon() || p->isAntiKaon()) {
        theNkaonplusInitial += Math::heaviside(ParticleTable::getIsospin(p->getType()));
        theNkaonminusInitial += Math::heaviside(-ParticleTable::getIsospin(p->getType()));
      }
      if(p->isAntiNucleon()) {
        if (p->getZ()<0) theNantiprotonInitial += Math::heaviside(-ParticleTable::getIsospin(p->getType()));
        else theNantineutronInitial += Math::heaviside(ParticleTable::getIsospin(p->getType()));
      }
      if(!p->isTargetSpectator()) theStore->getBook().incrementCascading();
    };

Referenced by applyFinalState().

isEventTransparent()

G4bool G4INCL::Nucleus::isEventTransparent

(

)

const

Is the event transparent?

To be called at the end of the cascade.

Definition at line 994 of file G4INCLNucleus.cc.

                                           {
 
    Book const &theBook = theStore->getBook();
    const G4int nEventCollisions = theBook.getAcceptedCollisions();
    const G4int nEventDecays = theBook.getAcceptedDecays();
    const G4int nEventClusters = theBook.getEmittedClusters();
    if(nEventCollisions==0 && nEventDecays==0 && nEventClusters==0)
      return true;
 
    return false;
 
  }

isNucleusNucleusCollision()

G4bool G4INCL::Nucleus::isNucleusNucleusCollision ( ) const

inline

Is it a nucleus-nucleus collision?

Definition at line 507 of file G4INCLNucleus.hh.

{ return isNucleusNucleus; }

operator=()

Nucleus & G4INCL::Nucleus::operator=

(

const Nucleus &

rhs

)

Dummy assignment operator to silence Coverity warning.

print()

std::string G4INCL::Nucleus::print

(

)

Print the nucleus info

Definition at line 315 of file G4INCLNucleus.cc.

  {
    std::stringstream ss;
    ss << "Particles in the nucleus:" << '\n'
      << "Inside:" << '\n';
    G4int counter = 1;
    ParticleList const &inside = theStore->getParticles();
    for(ParticleIter p=inside.begin(), e=inside.end(); p!=e; ++p) {
      ss << "index = " << counter << '\n'
        << (*p)->print();
      counter++;
    }
    ss <<"Outgoing:" << '\n';
    ParticleList const &outgoing = theStore->getOutgoingParticles();
    for(ParticleIter p=outgoing.begin(), e=outgoing.end(); p!=e; ++p)
      ss << (*p)->print();
 
    return ss.str();
  }

propagateParticles()

void G4INCL::Nucleus::propagateParticles

(

G4double

step

)

Propagate the particles one time step.

Parameters

step	length of the time step

Definition at line 235 of file G4INCLNucleus.cc.

                                             {
    INCL_WARN("Useless Nucleus::propagateParticles -method called." << '\n');
  }

resetSrc()

void G4INCL::Nucleus::resetSrc ( )

inline

Resets the src partners.

Definition at line 403 of file G4INCLNucleus.hh.

                          {
      ParticleList const &inside = theStore->getParticles();
      for(ParticleIter i=inside.begin(), e=inside.end(); i!=e; ++i)
        (*i)->resetSrcPartner();
    }

restoreSrcPartner()

void G4INCL::Nucleus::restoreSrcPartner	(	Particle *	particle,
		ThreeVector	m )

Definition at line 335 of file G4INCLNucleus.cc.

                                                                 {
 
  std::cout << "restoreSrcPartner: " << particle->print() << std::endl;
  std::cout << "restoreSrcPartner: " << m.print() << std::endl;
 
  particle->setMomentum(m);
  particle->adjustEnergyFromMomentum();
 
  std::cout << "restoreSrcPartner bis: " << particle->print() << std::endl;
}

setAnnihilationType()

void G4INCL::Nucleus::setAnnihilationType ( const AnnihilationType at )

inline

Setter for theAnnihilationType.

Definition at line 562 of file G4INCLNucleus.hh.

                                                       {
      theAType = at;
    }; //D

setAType()

void G4INCL::Nucleus::setAType

(

AnnihilationType

type

)

Definition at line 138 of file G4INCLNucleus.cc.

                                              {
    theAType = type;
  }

setDensity()

void G4INCL::Nucleus::setDensity ( NuclearDensity const *const d )

inline

Setter for theDensity.

Definition at line 546 of file G4INCLNucleus.hh.

                                                    {
      theDensity=d;
      if(theParticleSampler)
        theParticleSampler->setDensity(theDensity);
    };

setIncomingAngularMomentum()

void G4INCL::Nucleus::setIncomingAngularMomentum ( const ThreeVector & j )

inline

Set the incoming angular-momentum vector.

Definition at line 301 of file G4INCLNucleus.hh.

                                                          {
      incomingAngularMomentum = j;
    }

setIncomingMomentum()

void G4INCL::Nucleus::setIncomingMomentum ( const ThreeVector & p )

inline

Set the incoming momentum vector.

Definition at line 309 of file G4INCLNucleus.hh.

                                                   {
      incomingMomentum = p;
    }

setInitialEnergy()

void G4INCL::Nucleus::setInitialEnergy ( const G4double e )

inline

Set the initial energy.

Definition at line 319 of file G4INCLNucleus.hh.

{ initialEnergy = e; }

setNucleusNucleusCollision()

void G4INCL::Nucleus::setNucleusNucleusCollision ( )

inline

Set a nucleus-nucleus collision.

Definition at line 510 of file G4INCLNucleus.hh.

{ isNucleusNucleus=true; }

setParticleNucleusCollision()

void G4INCL::Nucleus::setParticleNucleusCollision ( )

inline

Set a particle-nucleus collision.

Definition at line 513 of file G4INCLNucleus.hh.

{ isNucleusNucleus=false; }

setProjectileRemnant()

void G4INCL::Nucleus::setProjectileRemnant ( ProjectileRemnant *const c )

inline

Set the projectile remnant.

Definition at line 516 of file G4INCLNucleus.hh.

                                                           {
      delete theProjectileRemnant;
      theProjectileRemnant = c;
    }

setSrcInternalEnergy()

void G4INCL::Nucleus::setSrcInternalEnergy ( double value )

inline

Definition at line 409 of file G4INCLNucleus.hh.

                                                  {
      srcInternalEnergy = value;    
    }

setStore()

void G4INCL::Nucleus::setStore ( Store * str )

inline

Definition at line 429 of file G4INCLNucleus.hh.

                              {
      delete theStore;
      theStore = str;
    };

setUniverseRadius()

void G4INCL::Nucleus::setUniverseRadius ( const G4double universeRadius )

inline

Setter for theUniverseRadius.

Definition at line 504 of file G4INCLNucleus.hh.

{ theUniverseRadius=universeRadius; }

updateInternalEnergy()

void G4INCL::Nucleus::updateInternalEnergy ( double value )

inline

Definition at line 413 of file G4INCLNucleus.hh.

                                                  {
      initialInternalEnergy += value;
    }

updatePotentialEnergy()

void G4INCL::Nucleus::updatePotentialEnergy ( Particle * p ) const

inline

Update the particle potential energy.

Definition at line 541 of file G4INCLNucleus.hh.

                                                         {
      p->setPotentialEnergy(thePotential->computePotentialEnergy(p));
    }

Referenced by initializeParticles().

useFusionKinematics()

void G4INCL::Nucleus::useFusionKinematics

(

)

Adjust the kinematics for complete-fusion events.

Definition at line 1418 of file G4INCLNucleus.cc.

                                    {
    setEnergy(initialEnergy);
    setMomentum(incomingMomentum);
    setSpin(incomingAngularMomentum);
    theExcitationEnergy = std::sqrt(theEnergy*theEnergy-theMomentum.mag2()) - getTableMass();
    setMass(getTableMass() + theExcitationEnergy);
  }

---

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

• G4INCLNucleus.hh
• G4INCLNucleus.cc