G4INCL::Nucleus Class Reference

#include <G4INCLNucleus.hh>

Inheritance diagram for G4INCL::Nucleus:

Public Member Functions
	Nucleus (G4int mass, G4int charge, Config const *const conf, const G4double universeRadius=-1.)
virtual	~Nucleus ()
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
ParticleList const &	getCreatedParticles () const
ParticleList const &	getUpdatedParticles () const
Particle *	getBlockedDelta () const
	Get the delta that could not decay.
void	propagateParticles (G4double step)
G4int	getNumberOfEnteringProtons () const
G4int	getNumberOfEnteringNeutrons () 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	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	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.
std::string	print ()
std::string	dump ()
Store *	getStore () const
void	setStore (Store *s)
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 ()
G4int	getProjectileChargeNumber () const
	Return the charge number of the projectile.
G4int	getProjectileMassNumber () const
	Return the mass number of the projectile.
void	setProjectileChargeNumber (G4int n)
	Set the charge number of the projectile.
void	setProjectileMassNumber (G4int n)
	Set the mass number of the projectile.
G4bool	isForcedTransparent ()
	Returns true if a transparent event should be forced.
G4double	getTransmissionBarrier (Particle const *const p)
	Get the transmission barrier.
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	getCoulombRadius (ParticleSpecies const &p) const
	Get the Coulomb 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	moveProjectileRemnantComponentsToOutgoing ()
	Move the components of the projectile remnant to the outgoing list.
void	finalizeProjectileRemnant (const G4double emissionTime)
	Finalise the projectile remnant.
void	updatePotentialEnergy (Particle *p)
	Update the particle potential energy.
NuclearDensity *	getDensity () const
	Getter for theDensity.
NuclearPotential::INuclearPotential *	getPotential () const
	Getter for thePotential.
Data Structures
struct	ConservationBalance
	Struct for conservation laws. More...

---

Detailed Description

Definition at line 64 of file G4INCLNucleus.hh.

---

Constructor & Destructor Documentation

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

Definition at line 68 of file G4INCLNucleus.cc.

References G4INCL::ConstantPotential, G4INCL::NuclearDensityFactory::createDensity(), FATAL, G4INCL::Config::getPionPotential(), G4INCL::Config::getPotentialType(), G4INCL::NuclearPotential::INuclearPotential::getSeparationEnergy(), G4INCL::IsospinEnergyPotential, G4INCL::IsospinEnergySmoothPotential, G4INCL::IsospinPotential, G4INCL::Neutron, G4INCL::Proton, G4INCL::ParticleSampler::setDensity(), G4INCL::ParticleTable::setNeutronSeparationEnergy(), G4INCL::ParticleSampler::setPotential(), G4INCL::ParticleTable::setProtonSeparationEnergy(), G4INCL::Particle::theA, G4INCL::Cluster::theParticleSampler, and G4INCL::Particle::theZ.

    : Cluster(charge,mass),
     theInitialZ(charge), theInitialA(mass),
     theNpInitial(0), theNnInitial(0),
     initialInternalEnergy(0.),
     incomingAngularMomentum(0.,0.,0.), incomingMomentum(0.,0.,0.),
     initialCenterOfMass(0.,0.,0.),
     remnant(true),
     blockedDelta(NULL),
     initialEnergy(0.),
     tryCN(false),
     forceTransparent(false),
     projectileZ(0),
     projectileA(0),
     theUniverseRadius(universeRadius),
     isNucleusNucleus(false),
     theProjectileRemnant(NULL),
     theDensity(NULL),
     thePotential(NULL)
  {
    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;
    }
    switch(potentialType) {
      case IsospinEnergySmoothPotential:
        thePotential = new NuclearPotential::NuclearPotentialEnergyIsospinSmooth(theA, theZ, pionPotential);
        break;
      case IsospinEnergyPotential:
        thePotential = new NuclearPotential::NuclearPotentialEnergyIsospin(theA, theZ, pionPotential);
        break;
      case IsospinPotential:
        thePotential = new NuclearPotential::NuclearPotentialIsospin(theA, theZ, pionPotential);
        break;
      case ConstantPotential:
        thePotential = new NuclearPotential::NuclearPotentialConstant(theA, theZ, pionPotential);
        break;
      default:
        FATAL("Unrecognized potential type at Nucleus creation." << std::endl);
        break;
    }

    ParticleTable::setProtonSeparationEnergy(thePotential->getSeparationEnergy(Proton));
    ParticleTable::setNeutronSeparationEnergy(thePotential->getSeparationEnergy(Neutron));

    theDensity = NuclearDensityFactory::createDensity(theA, theZ);

    theParticleSampler->setPotential(thePotential);
    theParticleSampler->setDensity(theDensity);

    if(theUniverseRadius<0)
      theUniverseRadius = theDensity->getMaximumRadius();
    theStore = new Store(conf);
    toBeUpdated.clear();
  }

G4INCL::Nucleus::~Nucleus

(

)

[virtual]

Definition at line 130 of file G4INCLNucleus.cc.

                    {
    delete theStore;
    delete thePotential;
    /* We don't delete the density here any more -- the Factory is caching them
    delete theDensity;*/
  }

---

Member Function Documentation

void G4INCL::Nucleus::applyFinalState

(

FinalState *

)

Apply reaction final state information to the nucleus.

Definition at line 166 of file G4INCLNucleus.cc.

References G4INCL::Store::add(), G4INCL::Store::addToOutgoing(), DEBUG, deleted, ERROR, G4INCL::FinalState::getBlockedDelta(), G4INCL::Store::getBook(), G4INCL::FinalState::getCreatedParticles(), G4INCL::Book::getCurrentTime(), G4INCL::FinalState::getDestroyedParticles(), G4INCL::FinalState::getEnteringParticles(), G4INCL::FinalState::getModifiedParticles(), G4INCL::FinalState::getOutgoingParticles(), G4INCL::FinalState::getTotalEnergyBeforeInteraction(), G4INCL::FinalState::getValidity(), insertParticle(), G4INCL::ParticleBelowFermiFS, G4INCL::ParticleBelowZeroFS, G4INCL::Store::particleHasBeenDestroyed(), G4INCL::Store::particleHasBeenEjected(), G4INCL::Store::particleHasBeenUpdated(), G4INCL::PauliBlockedFS, G4INCL::FinalState::print(), G4INCL::Particle::theA, G4INCL::Particle::theZ, and G4INCL::ValidFS.

Referenced by decayInsideDeltas().

                                                      {
    justCreated.clear();
    toBeUpdated.clear(); // Clear the list of particles to be updated by the propagation model.
    blockedDelta = NULL;
    G4double totalEnergy = 0.0;

    FinalStateValidity const validity = finalstate->getValidity();
    if(validity == ValidFS) {

      ParticleList const &created = finalstate->getCreatedParticles();
      for(ParticleIter iter = created.begin(); iter != created.end(); ++iter) {
        theStore->add((*iter));
        if(!(*iter)->isOutOfWell()) {
          totalEnergy += (*iter)->getEnergy() - (*iter)->getPotentialEnergy();
          justCreated.push_back((*iter));   // New particle, so we must create avatars for it
        }
      }

      ParticleList const &deleted = finalstate->getDestroyedParticles();
      for(ParticleIter iter = deleted.begin(); iter != deleted.end(); ++iter) {
        theStore->particleHasBeenDestroyed((*iter)->getID());
      }

      ParticleList const &modified = finalstate->getModifiedParticles();
      for(ParticleIter iter = modified.begin(); iter != modified.end(); ++iter) {
        theStore->particleHasBeenUpdated((*iter)->getID());
        totalEnergy += (*iter)->getEnergy() - (*iter)->getPotentialEnergy();
        toBeUpdated.push_back((*iter)); // Particle is modified so we have to create new avatars for it.
      }

      ParticleList const &out = finalstate->getOutgoingParticles();
      for(ParticleIter iter = out.begin(); iter != out.end(); ++iter) {
        if((*iter)->isCluster()) {
          Cluster *clusterOut = dynamic_cast<Cluster*>((*iter));
          ParticleList const components = clusterOut->getParticles();
          for(ParticleIter in = components.begin(); in != components.end(); ++in)
            theStore->particleHasBeenEjected((*in)->getID());
        } else {
          theStore->particleHasBeenEjected((*iter)->getID());
        }
        totalEnergy += (*iter)->getEnergy();      // No potential here because the particle is gone
        theA -= (*iter)->getA();
        theZ -= (*iter)->getZ();
        theStore->addToOutgoing(*iter);
        (*iter)->setEmissionTime(theStore->getBook()->getCurrentTime());
      }

      ParticleList const &entering = finalstate->getEnteringParticles();
      for(ParticleIter iter = entering.begin(); iter != entering.end(); ++iter) {
        insertParticle(*iter);
        totalEnergy += (*iter)->getEnergy() - (*iter)->getPotentialEnergy();
        toBeUpdated.push_back((*iter)); // Particle is modified so we have to create new avatars for it.
      }
    } else if(validity == PauliBlockedFS) {
      blockedDelta = finalstate->getBlockedDelta();
    } else if(validity == ParticleBelowFermiFS) {
      DEBUG("A Particle is entering below the Fermi sea:" << std::endl << finalstate->print() << std::endl);
      tryCN = true;
      ParticleList const &entering = finalstate->getEnteringParticles();
      for(ParticleIter iter = entering.begin(); iter != entering.end(); ++iter) {
        insertParticle(*iter);
      }
    } else if(validity == ParticleBelowZeroFS) {
      DEBUG("A Particle is entering below zero energy:" << std::endl << finalstate->print() << std::endl);
      forceTransparent = true;
      ParticleList const &entering = finalstate->getEnteringParticles();
      for(ParticleIter iter = entering.begin(); iter != entering.end(); ++iter) {
        insertParticle(*iter);
      }
    }

    if(validity==ValidFS &&
        std::abs(totalEnergy - finalstate->getTotalEnergyBeforeInteraction()) > 0.1) {
      ERROR("Energy nonconservation! Energy at the beginning of the event = "
          << finalstate->getTotalEnergyBeforeInteraction()
          <<" and after interaction = "
          << totalEnergy << std::endl
          << finalstate->print());
    }
  }

ThreeVector G4INCL::Nucleus::computeCenterOfMass

(

)

const

Compute the current center-of-mass position.

Returns:

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

Definition at line 295 of file G4INCLNucleus.cc.

References G4INCL::Store::getParticles().

Referenced by computeRecoilKinematics().

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

G4double G4INCL::Nucleus::computeExcitationEnergy

(

)

const

Compute the current excitation energy.

Returns:

the excitation energy [MeV]

Definition at line 308 of file G4INCLNucleus.cc.

References computeSeparationEnergyBalance(), and computeTotalEnergy().

                                                  {
    const G4double totalEnergy = computeTotalEnergy();
    const G4double separationEnergies = computeSeparationEnergyBalance();

    return totalEnergy - initialInternalEnergy - separationEnergies;
  }

void G4INCL::Nucleus::computeRecoilKinematics

(

)

Compute the recoil momentum and spin of the nucleus.

Definition at line 265 of file G4INCLNucleus.cc.

References G4INCL::Particle::adjustEnergyFromMomentum(), computeCenterOfMass(), emitInsidePions(), G4INCL::Store::getOutgoingParticles(), G4INCL::ParticleTable::getTableMass, G4INCL::Particle::setMass(), G4INCL::Particle::theA, G4INCL::Cluster::theExcitationEnergy, G4INCL::Particle::theMomentum, G4INCL::Particle::thePosition, G4INCL::Cluster::theSpin, and G4INCL::Particle::theZ.

                                        {
    // 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 outgoing = theStore->getOutgoingParticles();
    for(ParticleIter p=outgoing.begin(); p!=outgoing.end(); ++p)
    {
      theMomentum -= (*p)->getMomentum();
      theSpin -= (*p)->getAngularMomentum();
    }

    // Subtract orbital angular momentum
    thePosition = computeCenterOfMass();
    theSpin -= (thePosition-initialCenterOfMass).vector(theMomentum);

    setMass(ParticleTable::getTableMass(theA,theZ) + theExcitationEnergy);
    adjustEnergyFromMomentum();
    remnant=true;
  }

G4double G4INCL::Nucleus::computeSeparationEnergyBalance

(

)

const [inline]

Outgoing - incoming separation energies.

Used by CDPP.

Definition at line 122 of file G4INCLNucleus.hh.

References G4INCL::Composite, G4INCL::DeltaMinus, G4INCL::DeltaPlus, G4INCL::DeltaPlusPlus, G4INCL::DeltaZero, G4INCL::Store::getOutgoingParticles(), G4INCL::NuclearPotential::INuclearPotential::getSeparationEnergy(), G4INCL::Neutron, G4INCL::PiMinus, G4INCL::PiPlus, and G4INCL::Proton.

Referenced by computeExcitationEnergy(), and G4INCL::CDPP::isBlocked().

                                                    {
      G4double S = 0.0;
      ParticleList outgoing = theStore->getOutgoingParticles();
      for(ParticleIter i = outgoing.begin(); i != outgoing.end(); ++i) {
        const ParticleType t = (*i)->getType();
        switch(t) {
          case Proton:
          case Neutron:
          case DeltaPlusPlus:
          case DeltaPlus:
          case DeltaZero:
          case DeltaMinus:
            S += thePotential->getSeparationEnergy(*i);
            break;
          case Composite:
            S += (*i)->getZ() * thePotential->getSeparationEnergy(Proton)
              + ((*i)->getA() - (*i)->getZ()) * thePotential->getSeparationEnergy(Neutron);
            break;
          case PiPlus:
            S += thePotential->getSeparationEnergy(Proton) - thePotential->getSeparationEnergy(Neutron);
            break;
          case PiMinus:
            S += thePotential->getSeparationEnergy(Neutron) - thePotential->getSeparationEnergy(Proton);
            break;
          default:
            break;
        }
      }

      S -= theNpInitial * thePotential->getSeparationEnergy(Proton);
      S -= theNnInitial * thePotential->getSeparationEnergy(Neutron);
      return S;
    }

G4double G4INCL::Nucleus::computeTotalEnergy

(

)

const

Compute the current total energy.

Returns:

the total energy [MeV]

Definition at line 251 of file G4INCLNucleus.cc.

References G4INCL::ParticleTable::effectiveNucleonMass, and G4INCL::Store::getParticles().

Referenced by computeExcitationEnergy(), and initializeParticles().

                                             {
    G4double totalEnergy = 0.0;
    ParticleList inside = theStore->getParticles();
    for(ParticleIter p=inside.begin(); p!=inside.end(); ++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
        totalEnergy += (*p)->getEnergy() - (*p)->getPotentialEnergy();
    }
    return totalEnergy;
  }

G4bool G4INCL::Nucleus::containsDeltas

(

)

[inline]

Returns true if the nucleus contains any deltas.

Definition at line 237 of file G4INCLNucleus.hh.

References G4INCL::Store::getParticles().

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

G4bool G4INCL::Nucleus::decayInsideDeltas

(

)

Force the decay of deltas inside the nucleus.

Returns:

true if any delta was forced to decay.

Definition at line 392 of file G4INCLNucleus.cc.

References applyFinalState(), DEBUG, emitInsidePions(), G4INCL::IAvatar::getFinalState(), G4INCL::Store::getParticles(), G4INCL::FinalState::getValidity(), G4INCL::NuclearPotential::INuclearPotential::hasPionPotential(), G4INCL::Particle::theA, G4INCL::Particle::theZ, and G4INCL::ValidFS.

                                    {
    /* 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 inside = theStore->getParticles();
    ParticleList deltas;
    for(ParticleIter i = inside.begin(); i != inside.end(); ++i)
      if((*i)->isDelta()) deltas.push_back((*i));

    // Loop over the deltas, make them decay
    for(ParticleIter i = deltas.begin(); i != deltas.end(); ++i) {
      DEBUG("Decay inside delta particle:" << std::endl
          << (*i)->print() << std::endl);
      // 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)
        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) {
      DEBUG("Remnant is unphysical: Z=" << theZ << ", A=" << theA << std::endl);
      emitInsidePions();
    }

    return true;
  }

G4bool G4INCL::Nucleus::decayMe

(

)

Force the phase-space decay of the Nucleus.

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

Returns:

true if the nucleus was forced to decay.

Definition at line 463 of file G4INCLNucleus.cc.

References G4INCL::Store::addToOutgoing(), G4INCL::ClusterDecay::decay(), G4INCL::Particle::theA, and G4INCL::Particle::theZ.

                          {
    // Do the phase-space decay only if Z=0 or Z=A
    if(theA<=1 || (theZ!=0 && theA!=theZ))
      return false;

    ParticleList decayProducts = ClusterDecay::decay(this);
    for(ParticleIter j = decayProducts.begin(); j!=decayProducts.end(); ++j)
      theStore->addToOutgoing(*j);

    return true;
  }

G4bool G4INCL::Nucleus::decayOutgoingClusters

(

)

Force the decay of unstable outgoing clusters.

Returns:

true if any cluster was forced to decay.

Definition at line 445 of file G4INCLNucleus.cc.

References G4INCL::Store::addToOutgoing(), G4INCL::ClusterDecay::decay(), and G4INCL::Store::getOutgoingParticles().

                                        {
    ParticleList out = theStore->getOutgoingParticles();
    ParticleList clusters;
    for(ParticleIter i = out.begin(); i != out.end(); ++i) {
      if((*i)->isCluster()) clusters.push_back((*i));
    }
    if(clusters.empty()) return false;

    for(ParticleIter i = clusters.begin(); i != clusters.end(); ++i) {
      Cluster *cluster = dynamic_cast<Cluster*>(*i); // Can't avoid using a cast here
      cluster->deleteParticles(); // Don't need them
      ParticleList decayProducts = ClusterDecay::decay(cluster);
      for(ParticleIter j = decayProducts.begin(); j!=decayProducts.end(); ++j)
        theStore->addToOutgoing(*j);
    }
    return true;
  }

G4bool G4INCL::Nucleus::decayOutgoingDeltas

(

)

Force the decay of outgoing deltas.

Returns:

true if any delta was forced to decay.

Definition at line 339 of file G4INCLNucleus.cc.

References G4INCL::Store::addToOutgoing(), G4INCL::Particle::adjustEnergyFromMomentum(), G4INCL::Particle::boost(), DEBUG, G4INCL::Store::getBook(), G4INCL::FinalState::getCreatedParticles(), G4INCL::Book::getCurrentTime(), G4INCL::IAvatar::getFinalState(), G4INCL::FinalState::getModifiedParticles(), G4INCL::Particle::getMomentum(), G4INCL::Store::getOutgoingParticles(), G4INCL::Particle::getTableMass(), G4INCL::ThreeVector::mag(), G4INCL::KinematicsUtils::momentumInCM(), G4INCL::Particle::setEmissionTime(), G4INCL::Particle::setMomentum(), and G4INCL::Particle::setTableMass().

                                      {
    ParticleList out = theStore->getOutgoingParticles();
    ParticleList deltas;
    for(ParticleIter i = out.begin(); i != out.end(); ++i) {
      if((*i)->isDelta()) deltas.push_back((*i));
    }
    if(deltas.empty()) return false;

    for(ParticleIter i = deltas.begin(); i != deltas.end(); ++i) {
      DEBUG("Decay outgoing delta particle:" << std::endl
          << (*i)->print() << std::endl);
      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(theStore->getBook()->getCurrentTime());
      pion->boost(beta);

      nucleon->setTableMass();
      nucleon->setMomentum(-newMomentum);
      nucleon->adjustEnergyFromMomentum();
      nucleon->setEmissionTime(theStore->getBook()->getCurrentTime());
      nucleon->boost(beta);

      theStore->addToOutgoing(pion);

      delete fs;
      delete decay;
    }

    return true;
  }

void G4INCL::Nucleus::deleteProjectileRemnant

(

)

[inline]

Delete the projectile remnant.

Definition at line 401 of file G4INCLNucleus.hh.

Referenced by finalizeProjectileRemnant().

                                   {
      delete theProjectileRemnant;
      theProjectileRemnant = NULL;
    }

std::string G4INCL::Nucleus::dump

(

)

Definition at line 152 of file G4INCLNucleus.cc.

References G4INCL::Store::getParticipants().

                          {
    std::stringstream ss;
    ss <<"(list ;; List of participants " << std::endl;
    ParticleList participants = theStore->getParticipants();
    for(ParticleIter i = participants.begin(); i != participants.end(); ++i) {
      ss <<"(make-particle-avatar-map " << std::endl
        << (*i)->dump() 
        << "(list ;; List of avatars in this particle" << std::endl
        << ")) ;; Close the list of avatars and the particle-avatar-map" << std::endl;
    }
    ss << ")" << std::endl;
    return ss.str();
  }

void G4INCL::Nucleus::emitInsidePions

(

)

Force emission of all pions inside the nucleus.

Definition at line 475 of file G4INCLNucleus.cc.

References G4INCL::Store::addToOutgoing(), G4INCL::Store::getBook(), G4INCL::Book::getCurrentTime(), G4INCL::Store::getParticles(), G4INCL::Store::particleHasBeenEjected(), G4INCL::Particle::theA, G4INCL::Particle::theZ, and WARN.

Referenced by computeRecoilKinematics(), and decayInsideDeltas().

                                {
    /* 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).
     */
    WARN("Forcing emissions of all pions in the nucleus." << std::endl);

    // Emit the pions with this kinetic energy
    const G4double tinyPionEnergy = 0.1; // MeV

    // Push out the emitted pions
    ParticleList inside = theStore->getParticles();
    for(ParticleIter i = inside.begin(); i != inside.end(); ++i) {
      if((*i)->isPion()) {
        (*i)->setEmissionTime(theStore->getBook()->getCurrentTime());
        // Correction for real masses
        const G4double theQValueCorrection = (*i)->getEmissionQValueCorrection(theA,theZ);
        const G4double kineticEnergyOutside = (*i)->getKineticEnergy() - (*i)->getPotentialEnergy() + theQValueCorrection;
        (*i)->setTableMass();
        if(kineticEnergyOutside > 0.0)
          (*i)->setEnergy((*i)->getMass()+kineticEnergyOutside);
        else
          (*i)->setEnergy((*i)->getMass()+tinyPionEnergy);
        (*i)->adjustMomentumFromEnergy();
        (*i)->setPotentialEnergy(0.);
        theZ -= (*i)->getZ();
        theStore->particleHasBeenEjected((*i)->getID());
        theStore->addToOutgoing(*i);
      }
    }
  }

void G4INCL::Nucleus::fillEventInfo

(

EventInfo *

eventInfo

)

Fill the event info which contains INCL output data

Definition at line 695 of file G4INCLNucleus.cc.

References G4INCL::EventInfo::A, G4INCL::EventInfo::ARem, G4INCL::CollisionAvatarType, G4INCL::DecayAvatarType, G4INCL::EventInfo::EKin, G4INCL::EventInfo::EKinRem, G4INCL::EventInfo::emissionTime, G4INCL::EventInfo::EStarRem, G4INCL::EventInfo::firstCollisionTime, G4INCL::EventInfo::firstCollisionXSec, G4INCL::EventInfo::forcedCompoundNucleus, G4INCL::Particle::getA(), G4INCL::Book::getAcceptedCollisions(), G4INCL::Book::getAcceptedDecays(), G4INCL::Book::getAvatars(), G4INCL::Book::getBlockedCollisions(), G4INCL::Book::getBlockedDecays(), G4INCL::Store::getBook(), getExcitationEnergy(), G4INCL::Book::getFirstCollisionTime(), G4INCL::Book::getFirstCollisionXSec(), G4INCL::Particle::getKineticEnergy(), G4INCL::Particle::getMomentum(), G4INCL::Store::getOutgoingParticles(), G4INCL::Cluster::getSpin(), getStore(), G4INCL::ThreeVector::getX(), G4INCL::ThreeVector::getY(), G4INCL::Particle::getZ(), G4INCL::ThreeVector::getZ(), hasRemnant(), G4INCL::PhysicalConstants::hc, G4INCL::EventInfo::history, G4INCL::EventInfo::JRem, G4INCL::EventInfo::jxRem, G4INCL::EventInfo::jyRem, G4INCL::EventInfo::jzRem, G4INCL::ThreeVector::mag(), G4INCL::EventInfo::nBlockedCollisions, G4INCL::EventInfo::nBlockedDecays, G4INCL::EventInfo::nCascadeParticles, G4INCL::EventInfo::nCollisionAvatars, G4INCL::EventInfo::nCollisions, G4INCL::EventInfo::nDecayAvatars, G4INCL::EventInfo::nDecays, G4INCL::Neutron, G4INCL::EventInfo::nParticles, G4INCL::EventInfo::nReflectionAvatars, G4INCL::EventInfo::nRemnants, G4INCL::EventInfo::nucleonAbsorption, G4INCL::EventInfo::origin, G4INCL::EventInfo::phi, G4INCL::ThreeVector::phi(), G4INCL::EventInfo::phiRem, G4INCL::PiMinus, G4INCL::EventInfo::pionAbsorption, G4INCL::PiPlus, G4INCL::PiZero, G4INCL::EventInfo::projectileType, G4INCL::Proton, G4INCL::EventInfo::px, G4INCL::EventInfo::pxRem, G4INCL::EventInfo::py, G4INCL::EventInfo::pyRem, G4INCL::EventInfo::pz, G4INCL::EventInfo::pzRem, G4INCL::SurfaceAvatarType, G4INCL::EventInfo::theta, G4INCL::ThreeVector::theta(), G4INCL::EventInfo::thetaRem, G4INCL::Math::toDegrees(), WARN, G4INCL::EventInfo::Z, and G4INCL::EventInfo::ZRem.

                                                  {
    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 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(); i != outgoingParticles.end(); ++i ) {
      // If the particle is a cluster and has excitation energy, treat it as a cluster
      if((*i)->isCluster()) {
        Cluster const * const c = dynamic_cast<Cluster *>(*i);
// assert(c);
#ifdef INCLXX_IN_GEANT4_MODE
        if(!c)
          continue;
#endif
        const G4double eStar = c->getExcitationEnergy();
        if(std::abs(eStar)>1E-10) {
          if(eStar<0.) {
            WARN("Negative excitation energy in outgoing cluster! EStar = " << eStar << std::endl);
          }
          eventInfo->ARem[eventInfo->nRemnants] = c->getA();
          eventInfo->ZRem[eventInfo->nRemnants] = c->getZ();
          eventInfo->EStarRem[eventInfo->nRemnants] = eStar;
          ThreeVector remnantSpin = c->getSpin();
          Float_t remnantSpinMag;
          if(eventInfo->ARem[eventInfo->nRemnants]%2==0) { // even-A nucleus
            remnantSpinMag = (G4int) (remnantSpin.mag()/PhysicalConstants::hc + 0.5);
          } else { // odd-A nucleus
            remnantSpinMag = ((G4int) (remnantSpin.mag()/PhysicalConstants::hc)) + 0.5;
          }
          remnantSpin *= remnantSpinMag/remnantSpin.mag();
          eventInfo->JRem[eventInfo->nRemnants] = remnantSpinMag;
          eventInfo->jxRem[eventInfo->nRemnants] = remnantSpin.getX();
          eventInfo->jyRem[eventInfo->nRemnants] = remnantSpin.getY();
          eventInfo->jzRem[eventInfo->nRemnants] = remnantSpin.getZ();
          eventInfo->EKinRem[eventInfo->nRemnants] = c->getKineticEnergy();
          ThreeVector mom = c->getMomentum();
          eventInfo->pxRem[eventInfo->nRemnants] = mom.getX();
          eventInfo->pyRem[eventInfo->nRemnants] = mom.getY();
          eventInfo->pzRem[eventInfo->nRemnants] = mom.getZ();
          eventInfo->thetaRem[eventInfo->nRemnants] = Math::toDegrees(mom.theta());
          eventInfo->phiRem[eventInfo->nRemnants] = Math::toDegrees(mom.phi());
          eventInfo->nRemnants++;
          continue; // don't add it as a particle
        }
      }

      // 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->A[eventInfo->nParticles] = (*i)->getA();
      eventInfo->Z[eventInfo->nParticles] = (*i)->getZ();
      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;
      eventInfo->history.push_back("");
      eventInfo->nParticles++;
    }
    eventInfo->nucleonAbsorption = isNucleonAbsorption;
    eventInfo->pionAbsorption = isPionAbsorption;
    eventInfo->nCascadeParticles = eventInfo->nParticles;

    // Remnant characteristics
    if(hasRemnant()) {
      eventInfo->ARem[eventInfo->nRemnants] = getA();
      eventInfo->ZRem[eventInfo->nRemnants] = getZ();
      eventInfo->EStarRem[eventInfo->nRemnants] = getExcitationEnergy();
      if(eventInfo->EStarRem[eventInfo->nRemnants]<0.) {
        WARN("Negative excitation energy! EStarRem = " << eventInfo->EStarRem[eventInfo->nRemnants] << std::endl);
      }
      if(eventInfo->ARem[eventInfo->nRemnants]%2==0) { // even-A nucleus
        eventInfo->JRem[eventInfo->nRemnants] = (G4int) (getSpin().mag()/PhysicalConstants::hc + 0.5);
      } else { // odd-A nucleus
        eventInfo->JRem[eventInfo->nRemnants] = ((G4int) (getSpin().mag()/PhysicalConstants::hc)) + 0.5;
      }
      eventInfo->EKinRem[eventInfo->nRemnants] = getKineticEnergy();
      ThreeVector mom = getMomentum();
      eventInfo->pxRem[eventInfo->nRemnants] = mom.getX();
      eventInfo->pyRem[eventInfo->nRemnants] = mom.getY();
      eventInfo->pzRem[eventInfo->nRemnants] = mom.getZ();
      eventInfo->thetaRem[eventInfo->nRemnants] = Math::toDegrees(mom.theta());
      eventInfo->phiRem[eventInfo->nRemnants] = Math::toDegrees(mom.phi());
      eventInfo->nRemnants++;
    }

    // Global counters, flags, etc.
    eventInfo->nCollisions = getStore()->getBook()->getAcceptedCollisions();
    eventInfo->nBlockedCollisions = getStore()->getBook()->getBlockedCollisions();
    eventInfo->nDecays = getStore()->getBook()->getAcceptedDecays();
    eventInfo->nBlockedDecays = getStore()->getBook()->getBlockedDecays();
    eventInfo->firstCollisionTime = getStore()->getBook()->getFirstCollisionTime();
    eventInfo->firstCollisionXSec = getStore()->getBook()->getFirstCollisionXSec();
    eventInfo->nReflectionAvatars = getStore()->getBook()->getAvatars(SurfaceAvatarType);
    eventInfo->nCollisionAvatars = getStore()->getBook()->getAvatars(CollisionAvatarType);
    eventInfo->nDecayAvatars = getStore()->getBook()->getAvatars(DecayAvatarType);
  }

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 869 of file G4INCLNucleus.cc.

References G4INCL::Store::addToOutgoing(), deleteProjectileRemnant(), G4INCL::Particle::getA(), G4INCL::Particle::getInvariantMass(), G4INCL::ProjectileRemnant::getNumberStoredComponents(), G4INCL::Cluster::getParticles(), G4INCL::ParticleTable::getTableMass, G4INCL::Particle::getZ(), G4INCL::Particle::setEmissionTime(), G4INCL::Cluster::setExcitationEnergy(), G4INCL::Particle::setMass(), G4INCL::Cluster::setSpin(), and G4INCL::DeJongSpin::shoot().

                                                                       {
    // Deal with the projectile remnant
    if(theProjectileRemnant->getA()>1) {
      // Set the mass
      const G4double aMass = theProjectileRemnant->getInvariantMass();
      theProjectileRemnant->setMass(aMass);

      // Compute the excitation energy from the invariant mass
      const G4double anExcitationEnergy = aMass
        - ParticleTable::getTableMass(theProjectileRemnant->getA(), theProjectileRemnant->getZ());

      // Set the excitation energy
      theProjectileRemnant->setExcitationEnergy(anExcitationEnergy);

      // Set the spin
      theProjectileRemnant->setSpin(DeJongSpin::shoot(theProjectileRemnant->getNumberStoredComponents(), theProjectileRemnant->getA()));

      // Set the emission time
      theProjectileRemnant->setEmissionTime(anEmissionTime);

      // Put it in the outgoing list
      theStore->addToOutgoing(theProjectileRemnant);

      // NULL theProjectileRemnant
      theProjectileRemnant = NULL;
    } else if(theProjectileRemnant->getA()==1) {
      // Put the nucleon in the outgoing list
      Particle *theNucleon = theProjectileRemnant->getParticles().front();
      theStore->addToOutgoing(theNucleon);
      // Delete the remnant
      deleteProjectileRemnant();
    } else
      deleteProjectileRemnant();
  }

Particle* G4INCL::Nucleus::getBlockedDelta

(

)

const [inline]

Get the delta that could not decay.

Definition at line 106 of file G4INCLNucleus.hh.

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

{ return blockedDelta; }

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

Compute charge, mass, energy and momentum balance.

Definition at line 827 of file G4INCLNucleus.cc.

References G4INCL::Nucleus::ConservationBalance::A, G4INCL::EventInfo::Ap, G4INCL::EventInfo::At, G4INCL::Nucleus::ConservationBalance::energy, G4INCL::Particle::getA(), getExcitationEnergy(), getIncomingMomentum(), getInitialEnergy(), G4INCL::Particle::getKineticEnergy(), G4INCL::Particle::getMomentum(), G4INCL::Store::getOutgoingParticles(), G4INCL::ParticleTable::getTableMass, G4INCL::Particle::getZ(), hasRemnant(), G4INCL::Nucleus::ConservationBalance::momentum, G4INCL::Nucleus::ConservationBalance::Z, G4INCL::EventInfo::Zp, and G4INCL::EventInfo::Zt.

                                                                                                                          {
    ConservationBalance theBalance;
    // Initialise balance variables with the incoming values
    theBalance.Z = theEventInfo.Zp + theEventInfo.Zt;
    theBalance.A = theEventInfo.Ap + theEventInfo.At;

    theBalance.energy = getInitialEnergy();
    theBalance.momentum = getIncomingMomentum();

    // Process outgoing particles
    ParticleList outgoingParticles = theStore->getOutgoingParticles();
    for( ParticleIter i = outgoingParticles.begin(); i != outgoingParticles.end(); ++i ) {
      theBalance.Z -= (*i)->getZ();
      theBalance.A -= (*i)->getA();
      // 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();
    }

    // Remnant contribution, if present
    if(hasRemnant()) {
      theBalance.Z -= getZ();
      theBalance.A -= getA();
      theBalance.energy -= ParticleTable::getTableMass(getA(),getZ()) +
        getExcitationEnergy();
      if(afterRecoil)
        theBalance.energy -= getKineticEnergy();
      theBalance.momentum -= getMomentum();
    }

    return theBalance;
  }

G4double G4INCL::Nucleus::getCoulombRadius

(

ParticleSpecies const &

p

)

const [inline]

Get the Coulomb radius for a given particle.

That's the radius of the sphere that the Coulomb trajectory of the incoming particle should intersect. The intersection point is used to determine the effective impact parameter of the trajectory and the new entrance angle.

If the particle is not a Cluster, the Coulomb radius reduces to the surface radius. We use a parametrisation for d, t, He3 and alphas. For heavier clusters we fall back to the surface radius.

Parameters:

p

the particle species

Returns:

Coulomb radius

Definition at line 350 of file G4INCLNucleus.hh.

References G4InuclParticleNames::ap, G4INCL::Composite, ERROR, G4INCL::ParticleTable::eSquared, getUniverseRadius(), G4INCL::Math::pow23(), G4INCL::Particle::theA, G4INCL::ParticleSpecies::theA, G4INCL::ParticleSpecies::theType, G4INCL::Particle::theZ, and G4INCL::ParticleSpecies::theZ.

                                                              {
      if(p.theType == Composite) {
        const G4int zp = p.theZ;
        const G4int ap = p.theA;
        G4double barr, radius = 0.;
        if(zp==1 && ap==2) { // d
          barr = 0.2565*Math::pow23((G4double)theA)-0.78;
          radius = ParticleTable::eSquared*zp*theZ/barr - 2.5;
        } else if((zp==1 || zp==2) && ap==3) { // t, He3
          barr = 0.5*(0.5009*Math::pow23((G4double)theA)-1.16);
          radius = ParticleTable::eSquared*theZ/barr - 0.5;
        } else if(zp==2 && ap==4) { // alpha
          barr = 0.5939*Math::pow23((G4double)theA)-1.64;
          radius = ParticleTable::eSquared*zp*theZ/barr - 0.5;
        } else if(zp>2) {
          radius = getUniverseRadius();
        }
        if(radius<=0.) {
          ERROR("Negative Coulomb radius! Using the universe radius" << std::endl);
          radius = getUniverseRadius();
        }
        return radius;
      } else
        return getUniverseRadius();
    }

ParticleList const& G4INCL::Nucleus::getCreatedParticles

(

)

const [inline]

Get the list of particles that were created by the last applied final state

Definition at line 98 of file G4INCLNucleus.hh.

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

{ return justCreated; }

NuclearDensity* G4INCL::Nucleus::getDensity

(

)

const [inline]

Getter for theDensity.

Definition at line 428 of file G4INCLNucleus.hh.

Referenced by G4INCL::CoulombNonRelativistic::distortOut(), G4INCL::PauliStandard::getBlockingProbability(), and G4INCL::ClusteringModelIntercomparison::getCluster().

{ return theDensity; };

G4double G4INCL::Nucleus::getExcitationEnergy

(

)

const [inline]

Get the excitation energy of the nucleus.

Method computeRecoilKinematics() should be called first.

Reimplemented from G4INCL::Cluster.

Definition at line 234 of file G4INCLNucleus.hh.

References G4INCL::Cluster::theExcitationEnergy.

Referenced by fillEventInfo(), and getConservationBalance().

{ return theExcitationEnergy; }

const ThreeVector& G4INCL::Nucleus::getIncomingAngularMomentum

(

)

const [inline]

Get the incoming angular-momentum vector.

Definition at line 212 of file G4INCLNucleus.hh.

{ return incomingAngularMomentum; }

const ThreeVector& G4INCL::Nucleus::getIncomingMomentum

(

)

const [inline]

Get the incoming momentum vector.

Definition at line 220 of file G4INCLNucleus.hh.

Referenced by getConservationBalance().

                                                   {
      return incomingMomentum;
    }

G4int G4INCL::Nucleus::getInitialA

(

)

const [inline]

Definition at line 92 of file G4INCLNucleus.hh.

{ return theInitialA; };

G4double G4INCL::Nucleus::getInitialEnergy

(

)

const [inline]

Get the initial energy.

Definition at line 228 of file G4INCLNucleus.hh.

Referenced by getConservationBalance().

{ return initialEnergy; }

G4double G4INCL::Nucleus::getInitialInternalEnergy

(

)

const [inline]

Definition at line 257 of file G4INCLNucleus.hh.

Referenced by G4INCL::CDPP::isBlocked().

{ return initialInternalEnergy; };

G4int G4INCL::Nucleus::getInitialZ

(

)

const [inline]

Definition at line 93 of file G4INCLNucleus.hh.

{ return theInitialZ; };

G4int G4INCL::Nucleus::getNumberOfEnteringNeutrons

(

)

const [inline]

Definition at line 116 of file G4INCLNucleus.hh.

{ return theNnInitial; };

G4int G4INCL::Nucleus::getNumberOfEnteringProtons

(

)

const [inline]

Definition at line 115 of file G4INCLNucleus.hh.

{ return theNpInitial; };

NuclearPotential::INuclearPotential* G4INCL::Nucleus::getPotential

(

)

const [inline]

Getter for thePotential.

Definition at line 431 of file G4INCLNucleus.hh.

Referenced by G4INCL::PauliStandard::getBlockingProbability(), G4INCL::SurfaceAvatar::getChannel(), G4INCL::PionNucleonChannel::getFinalState(), G4INCL::ParticleEntryChannel::getFinalState(), and G4INCL::CDPP::isBlocked().

{ return thePotential; };

G4int G4INCL::Nucleus::getProjectileChargeNumber

(

)

const [inline]

Return the charge number of the projectile.

Definition at line 280 of file G4INCLNucleus.hh.

{ return projectileZ; }

G4int G4INCL::Nucleus::getProjectileMassNumber

(

)

const [inline]

Return the mass number of the projectile.

Definition at line 283 of file G4INCLNucleus.hh.

{ return projectileA; }

ProjectileRemnant* G4INCL::Nucleus::getProjectileRemnant

(

)

const [inline]

Get the projectile remnant.

Definition at line 398 of file G4INCLNucleus.hh.

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

{ return theProjectileRemnant; }

Store* G4INCL::Nucleus::getStore

(

)

const [inline]

Definition at line 251 of file G4INCLNucleus.hh.

Referenced by fillEventInfo(), G4INCL::StandardPropagationModel::generateAllAvatars(), G4INCL::StandardPropagationModel::generateBinaryCollisionAvatar(), G4INCL::PauliStandard::getBlockingProbability(), G4INCL::BinaryCollisionAvatar::getChannel(), G4INCL::ClusteringModelIntercomparison::getCluster(), G4INCL::INCL::initializeTarget(), G4INCL::PauliStrictStandard::isBlocked(), G4INCL::CDPP::isBlocked(), G4INCL::SurfaceAvatar::postInteraction(), G4INCL::InteractionAvatar::postInteraction(), G4INCL::DecayAvatar::postInteraction(), G4INCL::BinaryCollisionAvatar::postInteraction(), G4INCL::StandardPropagationModel::propagate(), G4INCL::StandardPropagationModel::registerAvatar(), G4INCL::StandardPropagationModel::shootComposite(), G4INCL::StandardPropagationModel::shootParticle(), G4INCL::InteractionAvatar::shouldUseLocalEnergy(), and G4INCL::StandardPropagationModel::updateAvatars().

{return theStore; };

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 322 of file G4INCLNucleus.hh.

References G4INCL::NuclearPotential::INuclearPotential::getFermiMomentum(), G4INCL::NuclearDensity::getMaxRFromP(), G4INCL::Particle::getMomentum(), getUniverseRadius(), G4INCL::Particle::isPion(), and G4INCL::ThreeVector::mag().

Referenced by G4INCL::InteractionAvatar::bringParticleInside(), G4INCL::StandardPropagationModel::generateBinaryCollisionAvatar(), G4INCL::StandardPropagationModel::getReflectionTime(), and G4INCL::InteractionAvatar::postInteraction().

                                                                     {
      if(particle->isPion())
        // Temporarily set RPION = RMAX
        return getUniverseRadius();
        //return 0.5*(theDensity->getTransmissionRadius(particle)+getUniverseRadius());
      else {
        const G4double pr = particle->getMomentum().mag()/thePotential->getFermiMomentum(particle);
        if(pr>=1.)
          return getUniverseRadius();
        else
          return theDensity->getMaxRFromP(pr);
      }
    }

G4double G4INCL::Nucleus::getTransmissionBarrier

(

Particle const *const

p

)

[inline]

Get the transmission barrier.

Definition at line 295 of file G4INCLNucleus.hh.

References G4INCL::PhysicalConstants::eSquared, G4INCL::NuclearDensity::getTransmissionRadius(), G4INCL::Particle::getZ(), and G4INCL::Particle::theZ.

Referenced by G4INCL::SurfaceAvatar::getTransmissionProbability(), and G4INCL::InteractionAvatar::postInteraction().

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

G4bool G4INCL::Nucleus::getTryCompoundNucleus

(

)

[inline]

Definition at line 277 of file G4INCLNucleus.hh.

{ return tryCN; }

G4double G4INCL::Nucleus::getUniverseRadius

(

)

const [inline]

Getter for theUniverseRadius.

Definition at line 377 of file G4INCLNucleus.hh.

Referenced by G4INCL::PauliStandard::getBlockingProbability(), G4INCL::ClusteringModelIntercomparison::getCluster(), getCoulombRadius(), getSurfaceRadius(), G4INCL::StandardPropagationModel::shootComposite(), and G4INCL::StandardPropagationModel::shootParticle().

{ return theUniverseRadius; }

ParticleList const& G4INCL::Nucleus::getUpdatedParticles

(

)

const [inline]

Get the list of particles that were updated by the last applied final state

Definition at line 103 of file G4INCLNucleus.hh.

Referenced by G4INCL::StandardPropagationModel::generateAllAvatars(), and G4INCL::StandardPropagationModel::propagate().

{ return toBeUpdated; }

G4bool G4INCL::Nucleus::hasRemnant

(

)

const [inline]

Does the nucleus give a cascade remnant?

To be called after computeRecoilKinematics().

Definition at line 269 of file G4INCLNucleus.hh.

Referenced by fillEventInfo(), and getConservationBalance().

{ return remnant; }

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 137 of file G4INCLNucleus.cc.

References G4INCL::Store::add(), computeTotalEnergy(), G4INCL::Cluster::initializeParticles(), G4INCL::Cluster::particles, G4INCL::Particle::thePosition, and updatePotentialEnergy().

Referenced by G4INCL::INCL::initializeTarget().

                                    {
    // Reset the variables connected with the projectile remnant
    delete theProjectileRemnant;
    theProjectileRemnant = NULL;

    Cluster::initializeParticles();
    for(ParticleIter i = particles.begin(); i != particles.end(); ++i) {
      updatePotentialEnergy(*i);
      theStore->add(*i);
    }
    particles.clear();
    initialInternalEnergy = computeTotalEnergy();
    initialCenterOfMass = thePosition;
  }

void G4INCL::Nucleus::insertParticle

(

Particle *

p

)

[inline]

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

Definition at line 76 of file G4INCLNucleus.hh.

References G4INCL::Particle::getA(), G4INCL::Store::getBook(), G4INCL::ParticleTable::getIsospin(), G4INCL::Particle::getType(), G4INCL::Particle::getZ(), G4INCL::Math::heaviside(), G4INCL::Book::incrementCascading(), G4INCL::Particle::isNucleon(), G4INCL::Particle::isTargetSpectator(), G4INCL::Store::particleHasEntered(), G4INCL::Particle::theA, and G4INCL::Particle::theZ.

Referenced by applyFinalState().

                                     {
      theZ += p->getZ();
      theA += p->getA();
      theStore->particleHasEntered(p);
      if(p->isNucleon()) {
        theNpInitial += Math::heaviside(ParticleTable::getIsospin(p->getType()));
        theNnInitial += Math::heaviside(-ParticleTable::getIsospin(p->getType()));
      }
      if(!p->isTargetSpectator()) theStore->getBook()->incrementCascading();
    };

G4bool G4INCL::Nucleus::isEventTransparent

(

)

const

Is the event transparent?

To be called at the end of the cascade.

Definition at line 507 of file G4INCLNucleus.cc.

References G4INCL::Particle::getA(), G4INCL::Store::getOutgoingParticles(), and G4INCL::Particle::getZ().

                                           {

    // Forced transparent
    if(forceTransparent)
      return true;

    ParticleList const &pL = theStore->getOutgoingParticles();
    G4int outZ = 0, outA = 0;

    // If any of the particles has undergone a collision, the event is not a
    // transparent.
    for(ParticleIter p = pL.begin(); p != pL.end(); ++p ) {
      if( (*p)->getNumberOfCollisions() != 0 ) return false;
      if( (*p)->getNumberOfDecays() != 0 ) return false;
      outZ += (*p)->getZ();
      outA += (*p)->getA();
    }

    // Add the geometrical spectators to the Z and A count
    if(theProjectileRemnant) {
      outZ += theProjectileRemnant->getZ();
      outA += theProjectileRemnant->getA();
    }

    if(outZ!=projectileZ || outA!=projectileA) return false;

    return true;

  }

G4bool G4INCL::Nucleus::isForcedTransparent

(

)

[inline]

Returns true if a transparent event should be forced.

Definition at line 292 of file G4INCLNucleus.hh.

{ return forceTransparent; }

G4bool G4INCL::Nucleus::isNucleusNucleusCollision

(

)

const [inline]

Is it a nucleus-nucleus collision?

Definition at line 383 of file G4INCLNucleus.hh.

Referenced by G4INCL::SurfaceAvatar::getChannel(), and G4INCL::ParticleEntryChannel::getFinalState().

{ return isNucleusNucleus; }

void G4INCL::Nucleus::moveProjectileRemnantComponentsToOutgoing

(

)

[inline]

Move the components of the projectile remnant to the outgoing list.

Definition at line 407 of file G4INCLNucleus.hh.

References G4INCL::Store::addToOutgoing(), G4INCL::Cluster::clearParticles(), and G4INCL::Cluster::getParticles().

                                                     {
      theStore->addToOutgoing(theProjectileRemnant->getParticles());
      theProjectileRemnant->clearParticles();
    }

std::string G4INCL::Nucleus::print

(

)

Print the nucleus info

Definition at line 315 of file G4INCLNucleus.cc.

References G4INCL::Store::getOutgoingParticles(), G4INCL::Store::getParticipants(), and G4INCL::Store::getSpectators().

  {
    std::stringstream ss;
    ss << "Particles in the nucleus:" << std::endl
      << "Participants:" << std::endl;
    G4int counter = 1;
    ParticleList participants = theStore->getParticipants();
    for(ParticleIter p = participants.begin(); p != participants.end(); ++p) {
      ss << "index = " << counter << std::endl
        << (*p)->print();
      counter++;
    }
    ss <<"Spectators:" << std::endl;
    ParticleList spectators = theStore->getSpectators();
    for(ParticleIter p = spectators.begin(); p != spectators.end(); ++p)
      ss << (*p)->print();
    ss <<"Outgoing:" << std::endl;
    ParticleList outgoing = theStore->getOutgoingParticles();
    for(ParticleIter p = outgoing.begin(); p != outgoing.end(); ++p)
      ss << (*p)->print();

    return ss.str();
  }

void G4INCL::Nucleus::propagateParticles

(

G4double

step

)

Propagate the particles one time step.

Parameters:

step

length of the time step

Definition at line 247 of file G4INCLNucleus.cc.

References WARN.

                                                    {
    WARN("Useless Nucleus::propagateParticles -method called." << std::endl);
  }

void G4INCL::Nucleus::setIncomingAngularMomentum

(

const ThreeVector &

j

)

[inline]

Set the incoming angular-momentum vector.

Definition at line 207 of file G4INCLNucleus.hh.

Referenced by G4INCL::StandardPropagationModel::shootComposite(), and G4INCL::StandardPropagationModel::shootParticle().

                                                          {
      incomingAngularMomentum = j;
    }

void G4INCL::Nucleus::setIncomingMomentum

(

const ThreeVector &

p

)

[inline]

Set the incoming momentum vector.

Definition at line 215 of file G4INCLNucleus.hh.

Referenced by G4INCL::StandardPropagationModel::shootComposite(), and G4INCL::StandardPropagationModel::shootParticle().

                                                   {
      incomingMomentum = p;
    }

void G4INCL::Nucleus::setInitialEnergy

(

const G4double

e

)

[inline]

Set the initial energy.

Definition at line 225 of file G4INCLNucleus.hh.

Referenced by G4INCL::StandardPropagationModel::shootComposite(), and G4INCL::StandardPropagationModel::shootParticle().

{ initialEnergy = e; }

void G4INCL::Nucleus::setNucleusNucleusCollision

(

)

[inline]

Set a nucleus-nucleus collision.

Definition at line 386 of file G4INCLNucleus.hh.

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

{ isNucleusNucleus=true; }

void G4INCL::Nucleus::setParticleNucleusCollision

(

)

[inline]

Set a particle-nucleus collision.

Definition at line 389 of file G4INCLNucleus.hh.

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

{ isNucleusNucleus=false; }

void G4INCL::Nucleus::setProjectileChargeNumber

(

G4int

n

)

[inline]

Set the charge number of the projectile.

Definition at line 286 of file G4INCLNucleus.hh.

Referenced by G4INCL::StandardPropagationModel::shootComposite(), and G4INCL::StandardPropagationModel::shootParticle().

{ projectileZ=n; }

void G4INCL::Nucleus::setProjectileMassNumber

(

G4int

n

)

[inline]

Set the mass number of the projectile.

Definition at line 289 of file G4INCLNucleus.hh.

Referenced by G4INCL::StandardPropagationModel::shootComposite(), and G4INCL::StandardPropagationModel::shootParticle().

{ projectileA=n; }

void G4INCL::Nucleus::setProjectileRemnant

(

ProjectileRemnant *const

c

)

[inline]

Set the projectile remnant.

Definition at line 392 of file G4INCLNucleus.hh.

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

                                                           {
      delete theProjectileRemnant;
      theProjectileRemnant = c;
    }

void G4INCL::Nucleus::setStore

(

Store *

s

)

[inline]

Definition at line 252 of file G4INCLNucleus.hh.

                            {
      delete theStore;
      theStore = s;
    };

void G4INCL::Nucleus::setUniverseRadius

(

const G4double

universeRadius

)

[inline]

Setter for theUniverseRadius.

Definition at line 380 of file G4INCLNucleus.hh.

{ theUniverseRadius=universeRadius; }

void G4INCL::Nucleus::updatePotentialEnergy

(

Particle *

p

)

[inline]

Update the particle potential energy.

Definition at line 423 of file G4INCLNucleus.hh.

References G4INCL::NuclearPotential::INuclearPotential::computePotentialEnergy(), and G4INCL::Particle::setPotentialEnergy().

Referenced by G4INCL::ReflectionChannel::getFinalState(), G4INCL::PionNucleonChannel::getFinalState(), and initializeParticles().

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

void G4INCL::Nucleus::useFusionKinematics

(

)

Adjust the kinematics for complete-fusion events.

Definition at line 861 of file G4INCLNucleus.cc.

References G4INCL::Cluster::getTableMass(), G4INCL::ThreeVector::mag2(), G4INCL::Particle::setEnergy(), G4INCL::Particle::setMass(), G4INCL::Particle::setMomentum(), G4INCL::Cluster::setSpin(), G4INCL::Particle::theEnergy, G4INCL::Cluster::theExcitationEnergy, and G4INCL::Particle::theMomentum.

                                    {
    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

---