G4INCL::BinaryCollisionAvatar Class Reference

#include <G4INCLBinaryCollisionAvatar.hh>

Inheritance diagram for G4INCL::BinaryCollisionAvatar:

Public Member Functions
	BinaryCollisionAvatar (G4double, G4double, G4INCL::Nucleus *, G4INCL::Particle *, G4INCL::Particle *)
virtual	~BinaryCollisionAvatar ()
G4INCL::IChannel *	getChannel () const
ParticleList	getParticles () const
virtual void	preInteraction ()
virtual FinalState *	postInteraction (FinalState *)
std::string	dump () const
Public Member Functions inherited from G4INCL::InteractionAvatar
	InteractionAvatar (G4double, G4INCL::Nucleus *, G4INCL::Particle *)
	InteractionAvatar (G4double, G4INCL::Nucleus *, G4INCL::Particle *, G4INCL::Particle *)
virtual	~InteractionAvatar ()
Public Member Functions inherited from G4INCL::IAvatar
	IAvatar ()
	IAvatar (G4double time)
virtual	~IAvatar ()
virtual G4INCL::IChannel *	getChannel () const =0
G4INCL::FinalState *	getFinalState ()
virtual void	preInteraction ()=0
virtual FinalState *	postInteraction (FinalState *)=0
G4double	getTime () const
virtual ParticleList	getParticles () const =0
virtual std::string	dump () const =0
AvatarType	getType () const
G4bool	isACollision () const
G4bool	isADecay () const
void	setType (AvatarType t)
long	getID () const
std::string	toString ()

Static Public Attributes
static const G4double	cutNN = 1910
static const G4double	cutNNSquared = cutNN*cutNN
Static Public Attributes inherited from G4INCL::InteractionAvatar
static const G4double	locEAccuracy = 1.E-4
	Target accuracy in the determination of the local-energy Q-value.
static const G4int	maxIterLocE = 50
	Max number of iterations for the determination of the local-energy Q-value.

Additional Inherited Members
Protected Member Functions inherited from G4INCL::InteractionAvatar
virtual G4INCL::IChannel *	getChannel () const =0
G4bool	bringParticleInside (Particle *const p)
void	preInteractionLocalEnergy (Particle *const p)
	Apply local-energy transformation, if appropriate.
void	preInteractionBlocking ()
	Store the state of the particles before the interaction.
void	preInteraction ()
FinalState *	postInteraction (FinalState *)
void	restoreParticles () const
	Restore the state of both particles.
G4bool	shouldUseLocalEnergy () const
	true if the given avatar should use local energy
G4bool	enforceEnergyConservation (FinalState *const fs)
	Enforce energy conservation.
Protected Attributes inherited from G4INCL::InteractionAvatar
G4INCL::Nucleus *	theNucleus
G4INCL::Particle *	particle1
G4INCL::Particle *	particle2
ThreeVector	boostVector
ParticleType	oldParticle1Type
ParticleType	oldParticle2Type
G4double	oldParticle1Energy
G4double	oldParticle2Energy
G4double	oldTotalEnergy
G4double	oldXSec
G4double	oldParticle1Potential
G4double	oldParticle2Potential
G4double	oldParticle1Mass
G4double	oldParticle2Mass
G4double	oldParticle1Helicity
G4double	oldParticle2Helicity
ThreeVector	oldParticle1Momentum
ThreeVector	oldParticle2Momentum
ThreeVector	oldParticle1Position
ThreeVector	oldParticle2Position
G4bool	isPiN
Protected Attributes inherited from G4INCL::IAvatar
G4double	theTime

Detailed Description

Definition at line 56 of file G4INCLBinaryCollisionAvatar.hh.

Constructor & Destructor Documentation

BinaryCollisionAvatar()

G4INCL::BinaryCollisionAvatar::BinaryCollisionAvatar	(	G4double	time,
		G4double	crossSection,
		G4INCL::Nucleus *	n,
		G4INCL::Particle *	p1,
		G4INCL::Particle *	p2
	)

Definition at line 68 of file G4INCLBinaryCollisionAvatar.cc.

    : InteractionAvatar(time, n, p1, p2), theCrossSection(crossSection)
  {
    setType(CollisionAvatarType);
  }

~BinaryCollisionAvatar()

G4INCL::BinaryCollisionAvatar::~BinaryCollisionAvatar ( )

virtual

Definition at line 75 of file G4INCLBinaryCollisionAvatar.cc.

                                                {
  }

Member Function Documentation

dump()

std::string G4INCL::BinaryCollisionAvatar::dump ( ) const

virtual

Implements G4INCL::IAvatar.

Definition at line 211 of file G4INCLBinaryCollisionAvatar.cc.

                                              {
    std::stringstream ss;
    ss << "(avatar " << theTime <<" 'nn-collision" << std::endl
      << "(list " << std::endl
      << particle1->dump()
      << particle2->dump()
      << "))" << std::endl;
    return ss.str();
  }

getChannel()

G4INCL::IChannel * G4INCL::BinaryCollisionAvatar::getChannel ( ) const

virtual

Check again the distance of approach. In order for the avatar to be realised, we have to perform a check in the CM system. We define a distance four-vector as

where is the distance vector of the particles at their minimum distance of approach (i.e. at the avatar time). By boosting this four-vector to the CM frame of the two particles and we obtain a new four vector

with a non-zero time component (the collision happens simultaneously for the two particles in the lab system, but not in the CM system). In order for the avatar to be realised, we require that

Note that ; thus, the condition above is more restrictive than the check that we perform in G4INCL::Propagation::StandardPropagationModel::generateBinaryCollisionAvatar. In other words, the avatar generation cannot miss any physical collision avatars.

Implements G4INCL::InteractionAvatar.

Definition at line 78 of file G4INCLBinaryCollisionAvatar.cc.

                                                          {
    // We already check cutNN at avatar creation time, but we have to check it
    // again here. For composite projectiles, we might have created independent
    // avatars with no cutNN before any collision took place.
    if(particle1->isNucleon()
        && particle2->isNucleon()
        && theNucleus->getStore()->getBook()->getAcceptedCollisions()!=0) {
      const G4double energyCM2 = KinematicsUtils::squareTotalEnergyInCM(particle1, particle2);
      // Below a certain cut value we don't do anything:
      if(energyCM2 < cutNNSquared) {
        DEBUG("CM energy = sqrt(" << energyCM2 << ") MeV < sqrt(" << cutNNSquared
            << ") MeV = cutNN" << "; returning a NULL channel" << std::endl);
        InteractionAvatar::restoreParticles();
        return NULL;
      }
    }
 
    /** Check again the distance of approach. In order for the avatar to be
     * realised, we have to perform a check in the CM system. We define a
     * distance four-vector as
     * \f[ (0, \Delta\vec{x}), \f]
     * where \f$\Delta\vec{x}\f$ is the distance vector of the particles at
     * their minimum distance of approach (i.e. at the avatar time). By
     * boosting this four-vector to the CM frame of the two particles and we
     * obtain a new four vector
     * \f[ (\Delta t', \Delta\vec{x}'), \f]
     * with a non-zero time component (the collision happens simultaneously for
     * the two particles in the lab system, but not in the CM system). In order
     * for the avatar to be realised, we require that
     * \f[ |\Delta\vec{x}'| \leq \sqrt{\sigma/\pi}.\f]
     * Note that \f$|\Delta\vec{x}'|\leq|\Delta\vec{x}|\f$; thus, the condition
     * above is more restrictive than the check that we perform in
     * G4INCL::Propagation::StandardPropagationModel::generateBinaryCollisionAvatar.
     * In other words, the avatar generation cannot miss any physical collision
     * avatars.
     */
    ThreeVector minimumDistance = particle1->getPosition();
    minimumDistance -= particle2->getPosition();
    const G4double betaDotX = boostVector.dot(minimumDistance);
    const G4double minDist = Math::tenPi*(minimumDistance.mag2() + betaDotX*betaDotX / (1.-boostVector.mag2()));
    if(minDist > theCrossSection) {
      DEBUG("CM distance of approach is too small: " << minDist << ">" <<
        theCrossSection <<"; returning a NULL channel" << std::endl);
      InteractionAvatar::restoreParticles();
      return NULL;
    }
 
    if(particle1->isNucleon() && particle2->isNucleon()) { // NN->NN
      G4double elasticCX = CrossSections::elastic(particle1,
          particle2);
      G4double deltaProductionCX = CrossSections::deltaProduction(particle1,
          particle2);
 
      G4bool isElastic = true;
      if(elasticCX/(elasticCX + deltaProductionCX) < Random::shoot()) {
        // NN -> N Delta channel is chosen
        isElastic = false;
      }
 
      if(isElastic) { // Elastic NN channel
        DEBUG("NN interaction: elastic channel chosen" << std::endl);
        return new ElasticChannel(theNucleus, particle1, particle2);
      } else { // Delta production
        // Inelastic NN channel
        DEBUG("NN interaction: inelastic channel chosen" << std::endl);
        return new DeltaProductionChannel(particle1, particle2, theNucleus);
      }
    } else if((particle1->isNucleon() && particle2->isDelta()) ||
          (particle1->isDelta() && particle2->isNucleon())) {
      G4double elasticCX = CrossSections::elastic(particle1,
          particle2);
      G4double recombinationCX = CrossSections::recombination(particle1,
          particle2);
 
      G4bool isElastic = true;
      if(elasticCX/(elasticCX + recombinationCX) < Random::shoot()) {
        // N Delta -> NN channel is chosen
        isElastic = false;
      }
 
      if(isElastic) { // Elastic N Delta channel
        DEBUG("NDelta interaction: elastic channel chosen" << std::endl);
        return new ElasticChannel(theNucleus, particle1, particle2);
      } else { // Recombination
        DEBUG("NDelta interaction: recombination channel chosen" << std::endl);
        return new RecombinationChannel(theNucleus, particle1, particle2);
      }
    } else if(particle1->isDelta() && particle2->isDelta()) {
        DEBUG("DeltaDelta interaction: elastic channel chosen" << std::endl);
        return new ElasticChannel(theNucleus, particle1, particle2);
    } else if((particle1->isNucleon() && particle2->isPion()) ||
          (particle1->isPion() && particle2->isNucleon())) {
      return new PionNucleonChannel(particle1, particle2, theNucleus, shouldUseLocalEnergy());
    } else {
      DEBUG("BinaryCollisionAvatar can only handle nucleons (for the moment)."
          << std::endl
          << particle1->print()
          << std::endl
          << particle2->print()
          << std::endl);
      InteractionAvatar::restoreParticles();
      return NULL;
    }
  }

getParticles()

ParticleList G4INCL::BinaryCollisionAvatar::getParticles ( ) const

inlinevirtual

Implements G4INCL::IAvatar.

Definition at line 61 of file G4INCLBinaryCollisionAvatar.hh.

                                      {
      ParticleList theParticleList;
      theParticleList.push_back(particle1);
      theParticleList.push_back(particle2);
      return theParticleList;
    };

postInteraction()

FinalState * G4INCL::BinaryCollisionAvatar::postInteraction ( FinalState *  fs )

virtual

Implements G4INCL::IAvatar.

Definition at line 187 of file G4INCLBinaryCollisionAvatar.cc.

                                                                   {
    // Call the postInteraction method of the parent class
    // (provides Pauli blocking and enforces energy conservation)
    fs = InteractionAvatar::postInteraction(fs);
 
    switch(fs->getValidity()) {
      case PauliBlockedFS:
        theNucleus->getStore()->getBook()->incrementBlockedCollisions();
        break;
      case NoEnergyConservationFS:
      case ParticleBelowFermiFS:
      case ParticleBelowZeroFS:
        break;
      case ValidFS:
        theNucleus->getStore()->getBook()->incrementAcceptedCollisions();
        if(theNucleus->getStore()->getBook()->getAcceptedCollisions() == 1) {
          G4double t = theNucleus->getStore()->getBook()->getCurrentTime();
          theNucleus->getStore()->getBook()->setFirstCollisionTime(t);
          theNucleus->getStore()->getBook()->setFirstCollisionXSec(oldXSec);
        }
    }
    return fs;
  }

preInteraction()

void G4INCL::BinaryCollisionAvatar::preInteraction ( )

virtual

Implements G4INCL::IAvatar.

Definition at line 183 of file G4INCLBinaryCollisionAvatar.cc.

                                             {
    InteractionAvatar::preInteraction();
  }

Member Data Documentation

cutNN

const G4double G4INCL::BinaryCollisionAvatar::cutNN = 1910

static

Definition at line 73 of file G4INCLBinaryCollisionAvatar.hh.

cutNNSquared

const G4double G4INCL::BinaryCollisionAvatar::cutNNSquared = cutNN*cutNN

static

Definition at line 74 of file G4INCLBinaryCollisionAvatar.hh.

Referenced by G4INCL::StandardPropagationModel::generateBinaryCollisionAvatar(), and getChannel().

---

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

• G4INCLBinaryCollisionAvatar.hh
• G4INCLBinaryCollisionAvatar.cc