G4HadPhaseSpaceKopylov Class Reference

#include <G4HadPhaseSpaceKopylov.hh>

Inheritance diagram for G4HadPhaseSpaceKopylov:

Public Member Functions
	G4HadPhaseSpaceKopylov (G4int verbose=0)
virtual	~G4HadPhaseSpaceKopylov ()
Public Member Functions inherited from G4VHadPhaseSpaceAlgorithm
	G4VHadPhaseSpaceAlgorithm (const G4String &algName, G4int verbose=0)
virtual	~G4VHadPhaseSpaceAlgorithm ()
Public Member Functions inherited from G4VHadDecayAlgorithm
	G4VHadDecayAlgorithm (const G4String &algName, G4int verbose=0)
virtual	~G4VHadDecayAlgorithm ()
void	Generate (G4double initialMass, const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState)
virtual void	SetVerboseLevel (G4int verbose)
G4int	GetVerboseLevel () const
const G4String &	GetName () const

Protected Member Functions
virtual void	GenerateMultiBody (G4double initialMass, const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState)
G4double	BetaKopylov (G4int K) const
Protected Member Functions inherited from G4VHadPhaseSpaceAlgorithm
virtual void	GenerateTwoBody (G4double initialMass, const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState)
G4ThreeVector	UniformVector (G4double mag=1.) const
Protected Member Functions inherited from G4VHadDecayAlgorithm
virtual void	GenerateTwoBody (G4double initialMass, const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState)=0
virtual void	GenerateMultiBody (G4double initialMass, const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState)=0
virtual G4bool	IsDecayAllowed (G4double initialMass, const std::vector< G4double > &masses) const
G4double	TwoBodyMomentum (G4double M0, G4double M1, G4double M2) const
G4double	UniformTheta () const
G4double	UniformPhi () const
void	PrintVector (const std::vector< G4double > &v, const G4String &name, std::ostream &os) const

Detailed Description

Definition at line 37 of file G4HadPhaseSpaceKopylov.hh.

Constructor & Destructor Documentation

G4HadPhaseSpaceKopylov()

G4HadPhaseSpaceKopylov::G4HadPhaseSpaceKopylov ( G4int  verbose = 0 )

inline

Definition at line 39 of file G4HadPhaseSpaceKopylov.hh.

    : G4VHadPhaseSpaceAlgorithm("G4HadPhaseSpaceKopylov",verbose) {;}

~G4HadPhaseSpaceKopylov()

virtual G4HadPhaseSpaceKopylov::~G4HadPhaseSpaceKopylov ( )

inlinevirtual

Definition at line 41 of file G4HadPhaseSpaceKopylov.hh.

{;}

Member Function Documentation

BetaKopylov()

G4double G4HadPhaseSpaceKopylov::BetaKopylov ( G4int  K ) const

protected

Definition at line 92 of file G4HadPhaseSpaceKopylov.cc.

                                                          {
  G4Pow* g4pow = G4Pow::GetInstance();
 
  G4int N = 3*K - 5;
  G4double xN = G4double(N);
  G4double Fmax = std::sqrt(g4pow->powN(xN/(xN+1.),N)/(xN+1.)); 
 
  G4double F, chi;
  const G4int maxNumberOfLoops = 10000;
  G4int loopCounter = 0;
  do {
    chi = G4UniformRand();
    F = std::sqrt(g4pow->powN(chi,N)*(1.-chi));      
  } while ( ( Fmax*G4UniformRand() > F ) && ++loopCounter < maxNumberOfLoops );  /* Loop checking, 02.11.2015, A.Ribon */ 
  if ( loopCounter >= maxNumberOfLoops ) {
    G4ExceptionDescription ed;
    ed << " Failed sampling after maxNumberOfLoops attempts : forced exit" << G4endl;
    G4Exception( " G4HadPhaseSpaceKopylov::BetaKopylov ", "HAD_KOPYLOV_001", JustWarning, ed );
  }
 
  return chi;
}

Referenced by GenerateMultiBody().

GenerateMultiBody()

void G4HadPhaseSpaceKopylov::GenerateMultiBody ( G4double  initialMass, const std::vector< G4double > &  masses, std::vector< G4LorentzVector > &  finalState  )

protectedvirtual

Implements G4VHadDecayAlgorithm.

Definition at line 43 of file G4HadPhaseSpaceKopylov.cc.

                                                  {
  if (GetVerboseLevel()) G4cout << GetName() << "::GenerateMultiBody" << G4endl;
 
  finalState.clear();
 
  G4int N = (G4int)masses.size();
  finalState.resize(N);
 
  G4double mtot = std::accumulate(masses.begin(), masses.end(), 0.0);
  G4double mu = mtot;
  G4double PFragMagCM = 0.0;
  G4double Mass = initialMass;
  G4double T = Mass-mtot;
  G4LorentzVector PFragCM(0.0,0.0,0.0,0.0);
  G4LorentzVector PRestCM(0.0,0.0,0.0,0.0);
  G4LorentzVector PRestLab(0.0,0.0,0.0,Mass);
 
  for (G4int k=N-1; k>0; --k) {
    mu -= masses[k];
    T *= (k>1) ? BetaKopylov(k) : 0.;
    
    G4double RestMass = mu + T;
    
    PFragMagCM = TwoBodyMomentum(Mass,masses[k],RestMass);
    
    // Create a unit vector with a random direction isotropically distributed
    G4ThreeVector RandVector = UniformVector(PFragMagCM);
    
    PFragCM.setVectM(RandVector,masses[k]);
    PRestCM.setVectM(-RandVector,RestMass);
 
    G4ThreeVector BoostV = PRestLab.boostVector();
    
    PFragCM.boost(BoostV);
    PRestCM.boost(BoostV);
    PRestLab = PRestCM;
    Mass = RestMass;
    finalState[k] = PFragCM;
  }
  
  finalState[0] = PRestLab;
}

---

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

• G4HadPhaseSpaceKopylov.hh
• G4HadPhaseSpaceKopylov.cc