#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 ()

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 ()

G4INCL::FinalState *	getFinalState ()

G4double	getTime () const

AvatarType	getType () const

G4bool	isACollision () const

G4bool	isADecay () const

void	setType (AvatarType t)

long	getID () const

std::string	toString ()

Static Public Member Functions
static void	setCutNN (const G4double c)

static G4double	getCutNN ()

static G4double	getCutNNSquared ()

Static Public Member Functions inherited from G4INCL::InteractionAvatar
static void	deleteBackupParticles ()
	Release the memory allocated for the backup particles. More...

Additional Inherited Members
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. More...

static const G4int	maxIterLocE = 50
	Max number of iterations for the determination of the local-energy Q-value. More...

Protected Member Functions inherited from G4INCL::InteractionAvatar
G4bool	bringParticleInside (Particle *const p)

void	preInteractionLocalEnergy (Particle *const p)
	Apply local-energy transformation, if appropriate. More...

void	preInteractionBlocking ()
	Store the state of the particles before the interaction. More...

void	preInteraction ()

FinalState *	postInteraction (FinalState *)

void	restoreParticles () const
	Restore the state of both particles. More...

G4bool	shouldUseLocalEnergy () const
	true if the given avatar should use local energy More...

G4bool	enforceEnergyConservation (FinalState *const fs)
	Enforce energy conservation. More...

Protected Attributes inherited from G4INCL::InteractionAvatar
Nucleus *	theNucleus

Particle *	particle1

Particle *	particle2

ThreeVector	boostVector

G4double	oldTotalEnergy

G4double	oldXSec

G4bool	isPiN

Protected Attributes inherited from G4INCL::IAvatar
G4double	theTime

Static Protected Attributes inherited from G4INCL::InteractionAvatar
static G4ThreadLocal Particle *	backupParticle1 = NULL

static G4ThreadLocal Particle *	backupParticle2 = NULL

Detailed Description

Definition at line 54 of file G4INCLBinaryCollisionAvatar.hh.

Constructor & Destructor Documentation

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

Definition at line 68 of file G4INCLBinaryCollisionAvatar.cc.

References G4INCL::CollisionAvatarType, and G4INCL::IAvatar::setType().

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

G4INCL::BinaryCollisionAvatar::~BinaryCollisionAvatar ( )

virtual

Definition at line 78 of file G4INCLBinaryCollisionAvatar.cc.

78 {

79 }

Member Function Documentation

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

virtual

Implements G4INCL::IAvatar.

Definition at line 235 of file G4INCLBinaryCollisionAvatar.cc.

References G4INCL::Particle::dump(), G4INCL::InteractionAvatar::particle1, G4INCL::InteractionAvatar::particle2, and G4INCL::IAvatar::theTime.

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

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

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

$(0, \Delta\vec{x}),$

where $\Delta\vec{x}$ 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

$(\Delta t', \Delta\vec{x}'),$

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

$|\Delta\vec{x}'| \leq \sqrt{\sigma/\pi}.$

Note that $|\Delta\vec{x}'|\leq|\Delta\vec{x}|$ ; 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 81 of file G4INCLBinaryCollisionAvatar.cc.

References G4INCL::InteractionAvatar::boostVector, G4INCL::CrossSections::deltaProduction(), G4INCL::ThreeVector::dot(), G4INCL::CrossSections::elastic(), G4INCL::Book::getAcceptedCollisions(), G4INCL::Store::getBook(), G4INCL::Particle::getPosition(), G4INCL::Nucleus::getStore(), INCL_DEBUG, G4INCL::Particle::isDelta(), G4INCL::Particle::isNucleon(), G4INCL::Particle::isPion(), G4INCL::ThreeVector::mag2(), G4INCL::InteractionAvatar::particle1, G4INCL::InteractionAvatar::particle2, G4INCL::Particle::print(), G4INCL::CrossSections::recombination(), G4INCL::InteractionAvatar::restoreParticles(), G4INCL::Random::shoot(), G4INCL::KinematicsUtils::squareTotalEnergyInCM(), G4INCL::Math::tenPi, and G4INCL::InteractionAvatar::theNucleus.

                                                     {
     // 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) {
         INCL_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) {
       INCL_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);
 
       if(elasticCX/(elasticCX + deltaProductionCX) < Random::shoot()) {
         // NN -> N Delta channel is chosen
         isElastic = false;
       } else
         isElastic = true;
 
       if(isElastic) { // Elastic NN channel
         INCL_DEBUG("NN interaction: elastic channel chosen" << std::endl);
         return new ElasticChannel(particle1, particle2);
       } else { // Delta production
         // Inelastic NN channel
         INCL_DEBUG("NN interaction: inelastic channel chosen" << std::endl);
         return new DeltaProductionChannel(particle1, particle2);
       }
     } else if((particle1->isNucleon() && particle2->isDelta()) ||
           (particle1->isDelta() && particle2->isNucleon())) {
       G4double elasticCX = CrossSections::elastic(particle1,
           particle2);
       G4double recombinationCX = CrossSections::recombination(particle1,
           particle2);
 
       if(elasticCX/(elasticCX + recombinationCX) < Random::shoot()) {
         // N Delta -> NN channel is chosen
         isElastic = false;
       } else
         isElastic = true;
 
       if(isElastic) { // Elastic N Delta channel
         INCL_DEBUG("NDelta interaction: elastic channel chosen" << std::endl);
         return new ElasticChannel(particle1, particle2);
       } else { // Recombination
         INCL_DEBUG("NDelta interaction: recombination channel chosen" << std::endl);
         return new RecombinationChannel(particle1, particle2);
       }
     } else if(particle1->isDelta() && particle2->isDelta()) {
       isElastic = true;
       INCL_DEBUG("DeltaDelta interaction: elastic channel chosen" << std::endl);
       return new ElasticChannel(particle1, particle2);
     } else if((particle1->isNucleon() && particle2->isPion()) ||
           (particle1->isPion() && particle2->isNucleon())) {
       isElastic = false;
       return new PionNucleonChannel(particle1, particle2, theNucleus);
     } else {
       INCL_DEBUG("BinaryCollisionAvatar can only handle nucleons (for the moment)."
           << std::endl
           << particle1->print()
           << std::endl
           << particle2->print()
           << std::endl);
       InteractionAvatar::restoreParticles();
       return NULL;
     }
   }

static G4double G4INCL::BinaryCollisionAvatar::getCutNN ( )

inlinestatic

Definition at line 76 of file G4INCLBinaryCollisionAvatar.hh.

76 { return cutNN; }

static G4double G4INCL::BinaryCollisionAvatar::getCutNNSquared ( )

inlinestatic

Definition at line 78 of file G4INCLBinaryCollisionAvatar.hh.

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

78 { return cutNNSquared; }

ParticleList G4INCL::BinaryCollisionAvatar::getParticles ( ) const

inlinevirtual

Implements G4INCL::IAvatar.

Definition at line 59 of file G4INCLBinaryCollisionAvatar.hh.

References G4INCL::InteractionAvatar::particle1, and G4INCL::InteractionAvatar::particle2.

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

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

virtual

Implements G4INCL::IAvatar.

Definition at line 194 of file G4INCLBinaryCollisionAvatar.cc.

References G4INCL::InteractionAvatar::backupParticle1, G4INCL::InteractionAvatar::backupParticle2, G4INCL::Book::getAcceptedCollisions(), G4INCL::Store::getBook(), G4INCL::Book::getCurrentTime(), G4INCL::Particle::getMomentum(), G4INCL::Particle::getPosition(), G4INCL::Nucleus::getStore(), G4INCL::FinalState::getValidity(), INCL_ERROR, G4INCL::Book::incrementAcceptedCollisions(), G4INCL::Book::incrementBlockedCollisions(), G4INCL::ThreeVector::mag(), G4INCL::NoEnergyConservationFS, G4INCL::InteractionAvatar::oldXSec, G4INCL::ParticleBelowFermiFS, G4INCL::ParticleBelowZeroFS, G4INCL::PauliBlockedFS, G4INCL::InteractionAvatar::postInteraction(), G4INCL::Book::setFirstCollisionIsElastic(), G4INCL::Book::setFirstCollisionSpectatorMomentum(), G4INCL::Book::setFirstCollisionSpectatorPosition(), G4INCL::Book::setFirstCollisionTime(), G4INCL::Book::setFirstCollisionXSec(), G4INCL::InteractionAvatar::theNucleus, and G4INCL::ValidFS.

                                                                    {
     // 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) {
           // Store time and cross section of the first collision
           G4double t = theNucleus->getStore()->getBook().getCurrentTime();
           theNucleus->getStore()->getBook().setFirstCollisionTime(t);
           theNucleus->getStore()->getBook().setFirstCollisionXSec(oldXSec);
 
           // Store position and momentum of the spectator on the first
           // collision
           if((isParticle1Spectator && isParticle2Spectator) || (!isParticle1Spectator && !isParticle2Spectator)) {
             INCL_ERROR("First collision must be within a target spectator and a non-target spectator");
           }
           if(isParticle1Spectator) {
             theNucleus->getStore()->getBook().setFirstCollisionSpectatorPosition(backupParticle1->getPosition().mag());
             theNucleus->getStore()->getBook().setFirstCollisionSpectatorMomentum(backupParticle1->getMomentum().mag());
           } else {
             theNucleus->getStore()->getBook().setFirstCollisionSpectatorPosition(backupParticle2->getPosition().mag());
             theNucleus->getStore()->getBook().setFirstCollisionSpectatorMomentum(backupParticle2->getMomentum().mag());
           }
 
           // Store the elasticity of the first collision
           theNucleus->getStore()->getBook().setFirstCollisionIsElastic(isElastic);
         }
     }
     return fs;
   }

void G4INCL::BinaryCollisionAvatar::preInteraction ( )

virtual

Implements G4INCL::IAvatar.

Definition at line 188 of file G4INCLBinaryCollisionAvatar.cc.

References G4INCL::Particle::isTargetSpectator(), G4INCL::InteractionAvatar::particle1, G4INCL::InteractionAvatar::particle2, and G4INCL::InteractionAvatar::preInteraction().

                                              {
     isParticle1Spectator = particle1->isTargetSpectator();
     isParticle2Spectator = particle2->isTargetSpectator();
     InteractionAvatar::preInteraction();
   }

static void G4INCL::BinaryCollisionAvatar::setCutNN ( const G4double c )

inlinestatic

Definition at line 71 of file G4INCLBinaryCollisionAvatar.hh.

References test::c.

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

                                            {
       cutNN = c;
       cutNNSquared = cutNN*cutNN;
     }

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

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation