G4INCL::PhaseSpaceKopylov Class Reference

Generate momenta using the Kopylov method. More...

#include <G4INCLPhaseSpaceKopylov.hh>

Inheritance diagram for G4INCL::PhaseSpaceKopylov:

Public Member Functions
void	generate (const G4double sqrtS, ParticleList &particles)
	Generate momenta according to a uniform, non-Lorentz-invariant phase-space model.
Public Member Functions inherited from G4INCL::IPhaseSpaceGenerator
	IPhaseSpaceGenerator ()
virtual	~IPhaseSpaceGenerator ()
virtual void	generate (const G4double sqrtS, ParticleList &particles)=0
	Generate an event in the CM frame.

Detailed Description

Generate momenta using the Kopylov method.

Definition at line 48 of file G4INCLPhaseSpaceKopylov.hh.

Member Function Documentation

generate()

void G4INCL::PhaseSpaceKopylov::generate ( const G4double  sqrtS, ParticleList &  particles  )

virtual

Generate momenta according to a uniform, non-Lorentz-invariant phase-space model.

This function will assign momenta to the particles in the list that is passed as an argument. The event is generated in the CM frame.

Parameters

sqrtS	total centre-of-mass energy of the system
particles	list of particles

Implements G4INCL::IPhaseSpaceGenerator.

Definition at line 63 of file G4INCLPhaseSpaceKopylov.cc.

                                                                                {
 
    boostV.setX(0.0);
    boostV.setY(0.0);
    boostV.setZ(0.0);
 
    const std::size_t N = particles.size();
    masses.resize(N);
    sumMasses.resize(N);
    std::transform(particles.begin(), particles.end(), masses.begin(), std::mem_fn(&Particle::getMass));
    std::partial_sum(masses.begin(), masses.end(), sumMasses.begin());
 
    G4double PFragMagCM = 0.0;
    G4double T = sqrtS-sumMasses.back();
// assert(T>-1.e-5);
    if(T<0.)
      T=0.;
 
    // The first particle in the list will pick up all the recoil
    Particle *restParticle = particles.front();
    restParticle->setMass(sqrtS);
    restParticle->adjustEnergyFromMomentum();
 
    G4int k=G4int(N-1);
    for (auto p=particles.rbegin(); k>0; ++p, --k) {
      const G4double mu = sumMasses[k-1];
      T *= (k>1) ? betaKopylov(k) : 0.;
 
      const G4double restMass = mu + T;
 
      PFragMagCM = KinematicsUtils::momentumInCM(restParticle->getMass(), masses[k], restMass);
      PFragCM = Random::normVector(PFragMagCM);
      (*p)->setMomentum(PFragCM);
      (*p)->adjustEnergyFromMomentum();
      restParticle->setMass(restMass);
      restParticle->setMomentum(-PFragCM);
      restParticle->adjustEnergyFromMomentum();
 
      (*p)->boost(boostV);
      restParticle->boost(boostV);
 
      boostV = -restParticle->boostVector();
    }
    restParticle->setMass(masses[0]);
    restParticle->adjustEnergyFromMomentum();
  }

---

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

• G4INCLPhaseSpaceKopylov.hh
• G4INCLPhaseSpaceKopylov.cc