Functions
void	transformToLocalEnergyFrame (Nucleus const const n, Particle const p)

G4double	getLocalEnergy (Nucleus const const n, Particle const p)

ThreeVector	makeBoostVector (Particle const const p1, Particle const const p2)

G4double	totalEnergyInCM (Particle const const p1, Particle const const p2)

G4double	squareTotalEnergyInCM (Particle const const p1, Particle const const p2)

G4double	momentumInCM (Particle const const p1, Particle const const p2)
	gives the momentum in the CM frame of two particles. More...

G4double	momentumInCM (const G4double E, const G4double M1, const G4double M2)

G4double	momentumInLab (Particle const const p1, Particle const const p2)
	gives the momentum in the lab frame of two particles. More...

G4double	momentumInLab (const G4double s, const G4double m1, const G4double m2)

G4double	sumTotalEnergies (const ParticleList &)

ThreeVector	sumMomenta (const ParticleList &)

G4double	energy (const ThreeVector &p, const G4double m)

G4double	invariantMass (const G4double E, const ThreeVector &p)

G4double	squareInvariantMass (const G4double E, const ThreeVector &p)

G4double	gammaFromKineticEnergy (const ParticleSpecies &p, const G4double EKin)

Function Documentation

G4double G4INCL::KinematicsUtils::energy	(	const ThreeVector &	p,
		const G4double	m
	)

Definition at line 156 of file G4INCLKinematicsUtils.cc.

References python.hepunit::m, and G4INCL::ThreeVector::mag2().

                                                           {
     return std::sqrt(p.mag2() + m*m);
   }

G4double G4INCL::KinematicsUtils::gammaFromKineticEnergy	(	const ParticleSpecies &	p,
		const G4double	EKin
	)

Definition at line 168 of file G4INCLKinematicsUtils.cc.

References G4INCL::Composite, G4INCL::ParticleTable::getTableMass, G4INCL::ParticleTable::getTableParticleMass, G4INCL::ParticleSpecies::theA, G4INCL::ParticleSpecies::theType, and G4INCL::ParticleSpecies::theZ.

                                                                                  {
     G4double mass;
     if(p.theType==Composite)
       mass = ParticleTable::getTableMass(p.theA, p.theZ);
     else
       mass = ParticleTable::getTableParticleMass(p.theType);
     return (1.+EKin/mass);
   }

G4double G4INCL::KinematicsUtils::getLocalEnergy	(	Nucleus const *const	n,
		Particle *const	p
	)

Definition at line 51 of file G4INCLKinematicsUtils.cc.

References G4INCL::Nucleus::getDensity(), G4INCL::NuclearPotential::INuclearPotential::getFermiMomentum(), G4INCL::Particle::getKineticEnergy(), G4INCL::Particle::getMass(), G4INCL::NuclearDensity::getMaximumRadius(), G4INCL::NuclearDensity::getMaxRFromP(), G4INCL::NuclearDensity::getMinPFromR(), G4INCL::Particle::getMomentum(), G4INCL::Particle::getPosition(), G4INCL::Nucleus::getPotential(), G4INCL::Particle::getPotentialEnergy(), G4INCL::Particle::getReflectionMomentum(), G4INCL::NuclearPotential::INuclearPotential::getSeparationEnergy(), G4INCL::Particle::getType(), G4INCL::Nucleus::getUniverseRadius(), INCL_WARN, G4INCL::ThreeVector::mag(), readPY::pl, and G4INCL::Particle::print().

Referenced by transformToLocalEnergyFrame().

                                                                        {
 // assert(!p->isPion()); // No local energy for pions
 
     G4double vloc = 0.0;
     const G4double r = p->getPosition().mag();
     const G4double mass = p->getMass();
 
     // Local energy is constant outside the surface
     if(r > n->getUniverseRadius()) {
       INCL_WARN("Tried to evaluate local energy for a particle outside the maximum radius."
             << std::endl << p->print() << std::endl
             << "Maximum radius = " << n->getDensity()->getMaximumRadius() << std::endl
             << "Universe radius = " << n->getUniverseRadius() << std::endl);
       return 0.0;
     }
 
     G4double pfl0 = 0.0;
     const ParticleType t = p->getType();
     const G4double kinE = p->getKineticEnergy();
     if(kinE <= n->getPotential()->getFermiEnergy(t)) {
       pfl0 = n->getPotential()->getFermiMomentum(p);
     } else {
       const G4double tf0 = p->getPotentialEnergy() - n->getPotential()->getSeparationEnergy(p);
       if(tf0<0.0) return 0.0;
       pfl0 = std::sqrt(tf0*(tf0 + 2.0*mass));
     }
     const G4double pReflection = p->getReflectionMomentum()/pfl0;
     const G4double reflectionRadius = n->getDensity()->getMaxRFromP(p->getType(), pReflection);
     const G4double pNominal = p->getMomentum().mag()/pfl0;
     const G4double nominalReflectionRadius = n->getDensity()->getMaxRFromP(p->getType(), pNominal);
     const G4double pl = pfl0*n->getDensity()->getMinPFromR(t, r*nominalReflectionRadius/reflectionRadius);
     vloc = std::sqrt(pl*pl + mass*mass) - mass;
 
     return vloc;
   }

G4double G4INCL::KinematicsUtils::invariantMass	(	const G4double	E,
		const ThreeVector &	p
	)

Definition at line 160 of file G4INCLKinematicsUtils.cc.

References squareInvariantMass().

Referenced by G4ReactionKinematics::TwoBodyScattering().

                                                                   {
     return std::sqrt(squareInvariantMass(E, p));
   }

ThreeVector G4INCL::KinematicsUtils::makeBoostVector	(	Particle const *const	p1,
		Particle const *const	p2
	)

Definition at line 87 of file G4INCLKinematicsUtils.cc.

References G4INCL::Particle::getEnergy(), and G4INCL::Particle::getMomentum().

Referenced by G4INCL::InteractionAvatar::preInteraction(), and squareTotalEnergyInCM().

                                                                                    {
     const G4double totalEnergy = p1->getEnergy() + p2->getEnergy();
     return ((p1->getMomentum() + p2->getMomentum())/totalEnergy);
   }

G4double G4INCL::KinematicsUtils::momentumInCM	(	Particle const *const	p1,
		Particle const *const	p2
	)

gives the momentum in the CM frame of two particles.

The formula is the following:

$p_{CM}^2 = \frac{z^2 - m_1^2 m_2^2}{2 z + m_1^2 + m_2^2}$

where $z$ is the scalar product of the momentum four-vectors:

$z = E_1 E_2 - \vec{p}_1\cdot\vec{p}_2$

Parameters

p1	pointer to particle 1
p2	pointer to particle 2

Returns: the absolute value of the momentum of any of the two particles in the CM frame, in MeV/c.

Definition at line 105 of file G4INCLKinematicsUtils.cc.

References G4INCL::ThreeVector::dot(), G4INCL::Particle::getEnergy(), G4INCL::Particle::getMass(), G4INCL::Particle::getMomentum(), INCL_ERROR, and z.

Referenced by G4INCL::DeltaDecayChannel::computeDecayTime(), G4INCL::PhaseSpaceDecay::decay(), G4INCL::Nucleus::decayOutgoingDeltas(), G4INCL::DeltaProductionChannel::getFinalState(), G4INCL::DeltaDecayChannel::getFinalState(), and G4INCL::RecombinationChannel::getFinalState().

                                                                               {
     const G4double m1sq = std::pow(p1->getMass(),2);
     const G4double m2sq = std::pow(p2->getMass(),2);
     const G4double z = p1->getEnergy()*p2->getEnergy() - p1->getMomentum().dot(p2->getMomentum());
     G4double pcm2 = (z*z-m1sq*m2sq)/(2*z+m1sq+m2sq);
     if(pcm2 < 0.0) {
       INCL_ERROR("momentumInCM: pcm2 == " << pcm2 << " < 0.0" << std::endl);
       pcm2 = 0.0;
     }
     return std::sqrt(pcm2);
   }

G4double G4INCL::KinematicsUtils::momentumInCM	(	const G4double	E,
		const G4double	M1,
		const G4double	M2
	)

Definition at line 117 of file G4INCLKinematicsUtils.cc.

                                                                                 {
     return 0.5*std::sqrt((E*E - std::pow(M1 + M2, 2))
              *(E*E - std::pow(M1 - M2, 2)))/E;
   }

G4double G4INCL::KinematicsUtils::momentumInLab	(	Particle const *const	p1,
		Particle const *const	p2
	)

gives the momentum in the lab frame of two particles.

Assumes particle 1 carries all the momentum and particle 2 is at rest.

The formula is the following:

$p_{lab}^2 = \frac{s^2 - 2 s (m_1^2 + m_2^2) + {(m_1^2 - m_2^2)}^2}{4 m_2^2}$

Parameters

p1	pointer to particle 1
p2	pointer to particle 2

Returns: the absolute value of the momentum of particle 1 in the lab frame, in MeV/c

Definition at line 133 of file G4INCLKinematicsUtils.cc.

References G4INCL::Particle::getMass(), python.hepunit::m2, and squareTotalEnergyInCM().

Referenced by G4INCL::CrossSectionsINCL46::deltaProduction(), G4INCL::CrossSectionsINCL46::elasticNNLegacy(), G4INCL::DeltaProductionChannel::getFinalState(), G4INCL::ElasticChannel::getFinalState(), and G4INCL::CrossSectionsINCL46::recombination().

                                                                                {
     const G4double m1 = p1->getMass();
     const G4double m2 = p2->getMass();
     const G4double s = squareTotalEnergyInCM(p1, p2);
     return momentumInLab(s, m1, m2);
   }

G4double G4INCL::KinematicsUtils::momentumInLab	(	const G4double	s,
		const G4double	m1,
		const G4double	m2
	)

Definition at line 122 of file G4INCLKinematicsUtils.cc.

References INCL_ERROR, and python.hepunit::m2.

                                                                                  {
     const G4double m1sq = m1*m1;
     const G4double m2sq = m2*m2;
     G4double plab2 = (s*s-2*s*(m1sq+m2sq)+(m1sq-m2sq)*(m1sq-m2sq))/(4*m2sq);
     if(plab2 < 0.0) {
       INCL_ERROR("momentumInLab: plab2 == " << plab2 << " < 0.0; m1sq == " << m1sq << "; m2sq == " << m2sq << "; s == " << s << std::endl);
       plab2 = 0.0;
     }
     return std::sqrt(plab2);
   }

G4double G4INCL::KinematicsUtils::squareInvariantMass	(	const G4double	E,
		const ThreeVector &	p
	)

Definition at line 164 of file G4INCLKinematicsUtils.cc.

References G4INCL::ThreeVector::mag2().

Referenced by invariantMass().

                                                                         {
     return E*E - p.mag2();
   }

G4double G4INCL::KinematicsUtils::squareTotalEnergyInCM	(	Particle const *const	p1,
		Particle const *const	p2
	)

Definition at line 96 of file G4INCLKinematicsUtils.cc.

References G4INCL::Particle::getEnergy(), INCL_ERROR, G4INCL::ThreeVector::mag2(), and makeBoostVector().

Referenced by G4INCL::CrossSectionsINCL46::elasticNNLegacy(), G4INCL::StandardPropagationModel::generateBinaryCollisionAvatar(), G4INCL::BinaryCollisionAvatar::getChannel(), G4INCL::ElasticChannel::getFinalState(), momentumInLab(), G4INCL::CrossSectionsINCL46::recombination(), and totalEnergyInCM().

                                                                                        {
     G4double beta2 = makeBoostVector(p1, p2).mag2();
     if(beta2 > 1.0) {
       INCL_ERROR("squareTotalEnergyInCM: beta2 == " << beta2 << " > 1.0" << std::endl);
       beta2 = 0.0;
     }
     return (1.0 - beta2)*std::pow(p1->getEnergy() + p2->getEnergy(), 2);
   }

ThreeVector G4INCL::KinematicsUtils::sumMomenta ( const ParticleList & pl )

Definition at line 148 of file G4INCLKinematicsUtils.cc.

                                                  {
     ThreeVector p(0.0, 0.0, 0.0);
     for(ParticleIter i=pl.begin(), e=pl.end(); i!=e; ++i) {
       p += (*i)->getMomentum();
     }
     return p;
   }

G4double G4INCL::KinematicsUtils::sumTotalEnergies ( const ParticleList & pl )

Definition at line 140 of file G4INCLKinematicsUtils.cc.

                                                     {
     G4double E = 0.0;
     for(ParticleIter i=pl.begin(), e=pl.end(); i!=e; ++i) {
       E += (*i)->getEnergy();
     }
     return E;
   }

G4double G4INCL::KinematicsUtils::totalEnergyInCM	(	Particle const *const	p1,
		Particle const *const	p2
	)

Definition at line 92 of file G4INCLKinematicsUtils.cc.

References squareTotalEnergyInCM().

Referenced by G4INCL::CrossSectionsINCL46::deltaProduction(), G4INCL::DeltaProductionChannel::getFinalState(), G4INCL::RecombinationChannel::getFinalState(), and G4INCL::CrossSectionsINCL46::pionNucleon().

                                                                                 {
     return std::sqrt(squareTotalEnergyInCM(p1,p2));
   }

void G4INCL::KinematicsUtils::transformToLocalEnergyFrame	(	Nucleus const *const	n,
		Particle *const	p
	)

Definition at line 44 of file G4INCLKinematicsUtils.cc.

References G4INCL::Particle::adjustMomentumFromEnergy(), G4INCL::Particle::getEnergy(), getLocalEnergy(), and G4INCL::Particle::setEnergy().

Referenced by G4INCL::StandardPropagationModel::generateBinaryCollisionAvatar(), and G4INCL::InteractionAvatar::preInteractionLocalEnergy().

                                                                                 {
     const G4double localEnergy = getLocalEnergy(n, p);
     const G4double localTotalEnergy = p->getEnergy() - localEnergy;
     p->setEnergy(localTotalEnergy);
     p->adjustMomentumFromEnergy();
   }

Functions

Function Documentation