G4HadPhaseSpaceKopylov Class Reference

#include <G4HadPhaseSpaceKopylov.hh>

Inheritance diagram for G4HadPhaseSpaceKopylov:

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

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

Private Attributes
G4String	name
G4int	verboseLevel

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;
}

References G4endl, G4Exception(), G4UniformRand, G4Pow::GetInstance(), JustWarning, and G4Pow::powN().

Referenced by GenerateMultiBody().

Generate()

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

inherited

Definition at line 48 of file G4VHadDecayAlgorithm.cc.

                                                            {
  if (verboseLevel) G4cout << GetName() << "::Generate" << G4endl;
 
  // Initialization and sanity check
  finalState.clear();
  if (!IsDecayAllowed(initialMass, masses)) return;
 
  // Allow different procedures for two-body or N-body distributions
  if (masses.size() == 2U) 
    GenerateTwoBody(initialMass, masses, finalState);
  else 
    GenerateMultiBody(initialMass, masses, finalState);
}

References G4cout, G4endl, G4VHadDecayAlgorithm::GenerateMultiBody(), G4VHadDecayAlgorithm::GenerateTwoBody(), G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::IsDecayAllowed(), and G4VHadDecayAlgorithm::verboseLevel.

Referenced by G4HadDecayGenerator::Generate().

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();
 
  size_t N = 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 (size_t 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;
}

References BetaKopylov(), CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), CLHEP::HepLorentzVector::setVectM(), G4VHadDecayAlgorithm::TwoBodyMomentum(), and G4VHadPhaseSpaceAlgorithm::UniformVector().

GenerateTwoBody()

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

protectedvirtualinherited

Implements G4VHadDecayAlgorithm.

Definition at line 50 of file G4VHadPhaseSpaceAlgorithm.cc.

                                                {
  if (GetVerboseLevel()>1) 
    G4cout << " >>> G4HadDecayGenerator::FillTwoBody" << G4endl;
 
  // Initialization and sanity check
  finalState.clear();
  if (masses.size() != 2U) return;  // Should not have been called
 
  // Momentum of final state (energy balance has already been checked)
  G4double p = TwoBodyMomentum(initialMass,masses[0],masses[1]);
  if (GetVerboseLevel()>2) G4cout << " finalState momentum = " << p << G4endl;
 
  finalState.resize(2);             // Allows filling by index
  finalState[0].setVectM(UniformVector(p), masses[0]);
  finalState[1].setVectM(-finalState[0].vect(), masses[1]);
}

References G4cout, G4endl, G4VHadDecayAlgorithm::GetVerboseLevel(), G4VHadDecayAlgorithm::TwoBodyMomentum(), and G4VHadPhaseSpaceAlgorithm::UniformVector().

GetName()

const G4String & G4VHadDecayAlgorithm::GetName ( ) const

inlineinherited

Definition at line 56 of file G4VHadDecayAlgorithm.hh.

{ return name; }

References G4VHadDecayAlgorithm::name.

Referenced by G4HadPhaseSpaceGenbod::AcceptEvent(), G4HadPhaseSpaceGenbod::AccumulateFinalState(), G4CascadeFinalStateAlgorithm::ChooseGenerators(), G4HadPhaseSpaceGenbod::ComputeWeight(), G4HadPhaseSpaceGenbod::ComputeWeightScale(), G4CascadeFinalStateAlgorithm::Configure(), G4CascadeFinalStateAlgorithm::FillDirections(), G4CascadeFinalStateAlgorithm::FillDirManyBody(), G4CascadeFinalStateAlgorithm::FillDirThreeBody(), G4HadPhaseSpaceGenbod::FillEnergySteps(), G4CascadeFinalStateAlgorithm::FillMagnitudes(), G4HadPhaseSpaceGenbod::FillRandomBuffer(), G4CascadeFinalStateAlgorithm::FillUsingKopylov(), G4HadDecayGenerator::G4HadDecayGenerator(), G4VHadDecayAlgorithm::Generate(), G4CascadeFinalStateAlgorithm::GenerateCosTheta(), G4HadPhaseSpaceGenbod::GenerateMomenta(), G4CascadeFinalStateAlgorithm::GenerateMultiBody(), G4HadPhaseSpaceGenbod::GenerateMultiBody(), GenerateMultiBody(), G4HadPhaseSpaceNBodyAsai::GenerateMultiBody(), G4CascadeFinalStateAlgorithm::GenerateTwoBody(), G4HadDecayGenerator::GetAlgorithmName(), G4HadPhaseSpaceGenbod::Initialize(), G4VHadDecayAlgorithm::IsDecayAllowed(), G4CascadeFinalStateAlgorithm::satisfyTriangle(), G4CascadeFinalStateAlgorithm::SaveKinematics(), and G4VHadDecayAlgorithm::TwoBodyMomentum().

GetVerboseLevel()

G4int G4VHadDecayAlgorithm::GetVerboseLevel ( ) const

inlineinherited

Definition at line 55 of file G4VHadDecayAlgorithm.hh.

{ return verboseLevel; }

References G4VHadDecayAlgorithm::verboseLevel.

Referenced by G4HadPhaseSpaceGenbod::AcceptEvent(), G4HadPhaseSpaceGenbod::AccumulateFinalState(), G4CascadeFinalStateAlgorithm::ChooseGenerators(), G4HadPhaseSpaceGenbod::ComputeWeight(), G4HadPhaseSpaceGenbod::ComputeWeightScale(), G4CascadeFinalStateAlgorithm::Configure(), G4CascadeFinalStateAlgorithm::FillDirections(), G4CascadeFinalStateAlgorithm::FillDirManyBody(), G4CascadeFinalStateAlgorithm::FillDirThreeBody(), G4HadPhaseSpaceGenbod::FillEnergySteps(), G4CascadeFinalStateAlgorithm::FillMagnitudes(), G4HadPhaseSpaceGenbod::FillRandomBuffer(), G4CascadeFinalStateAlgorithm::FillUsingKopylov(), G4CascadeFinalStateAlgorithm::GenerateCosTheta(), G4HadPhaseSpaceGenbod::GenerateMomenta(), G4CascadeFinalStateAlgorithm::GenerateMultiBody(), G4HadPhaseSpaceGenbod::GenerateMultiBody(), GenerateMultiBody(), G4HadPhaseSpaceNBodyAsai::GenerateMultiBody(), G4CascadeFinalStateAlgorithm::GenerateTwoBody(), G4VHadPhaseSpaceAlgorithm::GenerateTwoBody(), G4HadPhaseSpaceGenbod::Initialize(), G4CascadeFinalStateAlgorithm::satisfyTriangle(), and G4CascadeFinalStateAlgorithm::SaveKinematics().

IsDecayAllowed()

G4bool G4VHadDecayAlgorithm::IsDecayAllowed ( G4double  initialMass, const std::vector< G4double > &  masses  ) const

protectedvirtualinherited

Definition at line 67 of file G4VHadDecayAlgorithm.cc.

                                                    {
  G4bool okay =
    (initialMass > 0. && masses.size() >= 2 &&
     initialMass >= std::accumulate(masses.begin(),masses.end(),0.));
 
  if (verboseLevel) {
    G4cout << GetName() << "::IsDecayAllowed? initialMass " << initialMass
       << " " << masses.size() << " masses sum "
       << std::accumulate(masses.begin(),masses.end(),0.) << G4endl;
 
    if (verboseLevel>1) PrintVector(masses," ",G4cout);
 
    G4cout << " Returning " << okay << G4endl;
  }
 
  return okay;
}

References G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::PrintVector(), and G4VHadDecayAlgorithm::verboseLevel.

Referenced by G4VHadDecayAlgorithm::Generate().

PrintVector()

void G4VHadDecayAlgorithm::PrintVector ( const std::vector< G4double > &  v, const G4String &  name, std::ostream &  os  ) const

protectedinherited

Definition at line 121 of file G4VHadDecayAlgorithm.cc.

                                                     {
  os << " " << vname << "(" << v.size() << ") ";
  std::copy(v.begin(), v.end(), std::ostream_iterator<G4double>(os, " "));
  os << std::endl;
}

References field_utils::copy().

Referenced by G4HadPhaseSpaceGenbod::FillEnergySteps(), G4HadPhaseSpaceGenbod::FillRandomBuffer(), G4HadPhaseSpaceNBodyAsai::GenerateMultiBody(), G4HadPhaseSpaceGenbod::Initialize(), and G4VHadDecayAlgorithm::IsDecayAllowed().

SetVerboseLevel()

virtual void G4VHadDecayAlgorithm::SetVerboseLevel ( G4int  verbose )

inlinevirtualinherited

Reimplemented in G4CascadeFinalStateAlgorithm.

Definition at line 54 of file G4VHadDecayAlgorithm.hh.

{ verboseLevel = verbose; }

References G4VHadDecayAlgorithm::verboseLevel.

Referenced by G4CascadeFinalStateAlgorithm::SetVerboseLevel(), and G4HadDecayGenerator::SetVerboseLevel().

TwoBodyMomentum()

G4double G4VHadDecayAlgorithm::TwoBodyMomentum ( G4double  M0, G4double  M1, G4double  M2  ) const

protectedinherited

Definition at line 90 of file G4VHadDecayAlgorithm.cc.

                                              {
  G4double PSQ = (M0+M1+M2)*(M0+M1-M2)*(M0-M1+M2)*(M0-M1-M2);
  if (PSQ < 0.) {
    G4cout << GetName() << ":  problem of decay of M(GeV) " << M0/GeV 
       << " to M1(GeV) " << M1/GeV << " and M2(GeV) " << M2/GeV
       << " PSQ(MeV) " << PSQ/MeV << " < 0" << G4endl;
    // exception only if the problem is numerically significant
    if (PSQ < -CLHEP::eV) {
      throw G4HadronicException(__FILE__, __LINE__,"Error in decay kinematics");
    }
 
    PSQ = 0.;
  }
 
  return std::sqrt(PSQ)/(2.*M0);
}

References CLHEP::eV, G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), GeV, and MeV.

Referenced by G4HadPhaseSpaceGenbod::ComputeWeightScale(), G4HadPhaseSpaceGenbod::FillEnergySteps(), G4CascadeFinalStateAlgorithm::FillUsingKopylov(), GenerateMultiBody(), G4HadPhaseSpaceNBodyAsai::GenerateMultiBody(), G4CascadeFinalStateAlgorithm::GenerateTwoBody(), and G4VHadPhaseSpaceAlgorithm::GenerateTwoBody().

UniformPhi()

G4double G4VHadDecayAlgorithm::UniformPhi ( ) const

protectedinherited

Definition at line 114 of file G4VHadDecayAlgorithm.cc.

                                                {
  return twopi*G4UniformRand();
}

References G4UniformRand, and twopi.

Referenced by G4CascadeFinalStateAlgorithm::FillUsingKopylov(), G4CascadeFinalStateAlgorithm::GenerateTwoBody(), and G4VHadPhaseSpaceAlgorithm::UniformVector().

UniformTheta()

G4double G4VHadDecayAlgorithm::UniformTheta ( ) const

protectedinherited

Definition at line 110 of file G4VHadDecayAlgorithm.cc.

                                                  {
  return std::acos(2.0*G4UniformRand() - 1.0);
}

References G4UniformRand.

Referenced by G4CascadeFinalStateAlgorithm::FillUsingKopylov(), and G4VHadPhaseSpaceAlgorithm::UniformVector().

UniformVector()

G4ThreeVector G4VHadPhaseSpaceAlgorithm::UniformVector ( G4double  mag = 1. ) const

protectedinherited

Definition at line 73 of file G4VHadPhaseSpaceAlgorithm.cc.

                                                                         {
  // FIXME:  Should this be made a static thread-local buffer?
  G4ThreeVector v;
  v.setRThetaPhi(mag, UniformTheta(), UniformPhi());
  return v;
}

References CLHEP::Hep3Vector::setRThetaPhi(), G4VHadDecayAlgorithm::UniformPhi(), and G4VHadDecayAlgorithm::UniformTheta().

Referenced by GenerateMultiBody(), G4HadPhaseSpaceNBodyAsai::GenerateMultiBody(), and G4VHadPhaseSpaceAlgorithm::GenerateTwoBody().

Field Documentation

name

G4String G4VHadDecayAlgorithm::name

privateinherited

Definition at line 85 of file G4VHadDecayAlgorithm.hh.

Referenced by source.g4viscp.G4Scene::create_scene(), G4VHadDecayAlgorithm::GetName(), mcscore.MCParticle::printout(), and source.g4viscp.G4Scene::update_scene().

verboseLevel

G4int G4VHadDecayAlgorithm::verboseLevel

privateinherited

Definition at line 86 of file G4VHadDecayAlgorithm.hh.

Referenced by G4VHadDecayAlgorithm::Generate(), G4VHadDecayAlgorithm::GetVerboseLevel(), G4VHadDecayAlgorithm::IsDecayAllowed(), and G4VHadDecayAlgorithm::SetVerboseLevel().

---

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

• source/processes/hadronic/util/include/G4HadPhaseSpaceKopylov.hh
• source/processes/hadronic/util/src/G4HadPhaseSpaceKopylov.cc