G4HadPhaseSpaceGenbod Class Reference

#include <G4HadPhaseSpaceGenbod.hh>

Inheritance diagram for G4HadPhaseSpaceGenbod:

Public Member Functions
	G4HadPhaseSpaceGenbod (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	~G4HadPhaseSpaceGenbod ()

Protected Member Functions
G4bool	AcceptEvent () const
void	AccumulateFinalState (size_t i, const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState)
G4double	ComputeWeight () const
void	ComputeWeightScale (const std::vector< G4double > &masses)
void	FillEnergySteps (G4double initialMass, const std::vector< G4double > &masses)
void	FillRandomBuffer ()
void	GenerateMomenta (const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState)
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)
void	Initialize (G4double initialMass, const std::vector< G4double > &masses)
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
G4double	massExcess
std::vector< G4double >	meff
std::vector< G4double >	msq
std::vector< G4double >	msum
G4String	name
size_t	nFinal
G4int	nTrials
std::vector< G4double >	pd
std::vector< G4double >	rndm
G4double	totalMass
G4int	verboseLevel
G4double	weightMax

Detailed Description

Definition at line 37 of file G4HadPhaseSpaceGenbod.hh.

Constructor & Destructor Documentation

G4HadPhaseSpaceGenbod()

G4HadPhaseSpaceGenbod::G4HadPhaseSpaceGenbod

(

G4int

verbose = 0

)

Definition at line 51 of file G4HadPhaseSpaceGenbod.cc.

  : G4VHadPhaseSpaceAlgorithm("G4HadPhaseSpaceGenbod",verbose),
    nFinal(0), totalMass(0.), massExcess(0.), weightMax(0.), nTrials(0) {;}

~G4HadPhaseSpaceGenbod()

virtual G4HadPhaseSpaceGenbod::~G4HadPhaseSpaceGenbod ( )

inlinevirtual

Definition at line 40 of file G4HadPhaseSpaceGenbod.hh.

{;}

Member Function Documentation

AcceptEvent()

G4bool G4HadPhaseSpaceGenbod::AcceptEvent ( ) const

protected

Definition at line 170 of file G4HadPhaseSpaceGenbod.cc.

                                                {
  if (GetVerboseLevel()>1) 
    G4cout << GetName() << "::AcceptEvent? " << nTrials << G4endl;
 
  return (G4UniformRand() <= ComputeWeight());
}

References ComputeWeight(), G4cout, G4endl, G4UniformRand, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), and nTrials.

Referenced by GenerateMultiBody().

AccumulateFinalState()

void G4HadPhaseSpaceGenbod::AccumulateFinalState ( size_t  i, const std::vector< G4double > &  masses, std::vector< G4LorentzVector > &  finalState  )

protected

Definition at line 196 of file G4HadPhaseSpaceGenbod.cc.

                                                     {
  if (GetVerboseLevel()>2)
    G4cout << GetName() << "::AccumulateFinalState " << i << G4endl;
 
  if (i==0) {           // First final state particle left alone
    finalState[i].setVectM(G4ThreeVector(0.,pd[i],0.),masses[i]);
    return;
  }
  
  finalState[i].setVectM(G4ThreeVector(0.,-pd[i-1],0.),masses[i]);
  G4double phi = G4UniformRand() * twopi;
  G4double theta = std::acos(2.*G4UniformRand() - 1.);
 
  if (GetVerboseLevel() > 2) {
    G4cout << " initialized Py " << -pd[i-1] << " phi " << phi
       << " theta " << theta << G4endl;
  }
 
  G4double esys=0.,beta=0.,gamma=1.;
  if (i < nFinal-1) {           // Do not boost final particle
    esys = std::sqrt(pd[i]*pd[i]+meff[i]*meff[i]);
    beta = pd[i] / esys;
    gamma = esys / meff[i];
 
    if (GetVerboseLevel()>2)
      G4cout << " esys " << esys << " beta " << beta << " gamma " << gamma
         << G4endl;
  }
 
  for (size_t j=0; j<=i; j++) {     // Accumulate rotations
    finalState[j].rotateZ(theta).rotateY(phi);
    finalState[j].setY(gamma*(finalState[j].y() + beta*finalState[j].e()));
    if (GetVerboseLevel()>2) G4cout << " j " << j << " " << finalState[j] << G4endl;
  }
}

References anonymous_namespace{G4PionRadiativeDecayChannel.cc}::beta, G4cout, G4endl, G4UniformRand, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), meff, nFinal, pd, and twopi.

Referenced by GenerateMomenta().

ComputeWeight()

G4double G4HadPhaseSpaceGenbod::ComputeWeight ( ) const

protected

Definition at line 163 of file G4HadPhaseSpaceGenbod.cc.

                                                    {
  if (GetVerboseLevel()>1) G4cout << GetName() << "::ComputeWeight" << G4endl;
 
  return (std::accumulate(pd.begin(), pd.end(), 1./weightMax,
              std::multiplies<G4double>()));
}

References G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), pd, and weightMax.

Referenced by AcceptEvent().

ComputeWeightScale()

void G4HadPhaseSpaceGenbod::ComputeWeightScale ( const std::vector< G4double > &  masses )

protected

Definition at line 148 of file G4HadPhaseSpaceGenbod.cc.

                                                                           {
  if (GetVerboseLevel()>1) 
    G4cout << GetName() << "::ComputeWeightScale" << G4endl;
 
  weightMax = 1.;
  for (size_t i=1; i<nFinal; i++) {
    weightMax *= TwoBodyMomentum(massExcess+msum[i], msum[i-1], masses[i]);
  }
 
  if (GetVerboseLevel()>2) G4cout << " weightMax = " << weightMax << G4endl;
}

References G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), massExcess, msum, nFinal, G4VHadDecayAlgorithm::TwoBodyMomentum(), and weightMax.

Referenced by Initialize().

FillEnergySteps()

void G4HadPhaseSpaceGenbod::FillEnergySteps ( G4double  initialMass, const std::vector< G4double > &  masses  )

protected

Definition at line 123 of file G4HadPhaseSpaceGenbod.cc.

                                                          {
  if (GetVerboseLevel()>1) G4cout << GetName() << "::FillEnergySteps" << G4endl;
 
  meff.clear();
  pd.clear();
 
  meff.push_back(masses[0]);
  for (size_t i=1; i<nFinal-1; i++) {
    meff.push_back(rndm[i-1]*massExcess + msum[i]);
    pd.push_back(TwoBodyMomentum(meff[i], meff[i-1], masses[i]));
  }
  meff.push_back(initialMass);
  pd.push_back(TwoBodyMomentum(meff[nFinal-1], meff[nFinal-2], masses[nFinal-1]));
 
  if (GetVerboseLevel()>2) {
    PrintVector(meff,"meff",G4cout);
    PrintVector(pd,"pd",G4cout);
  }
}

References G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), massExcess, meff, msum, nFinal, pd, G4VHadDecayAlgorithm::PrintVector(), rndm, and G4VHadDecayAlgorithm::TwoBodyMomentum().

Referenced by GenerateMultiBody().

FillRandomBuffer()

void G4HadPhaseSpaceGenbod::FillRandomBuffer ( )

protected

Definition at line 110 of file G4HadPhaseSpaceGenbod.cc.

                                             {
  if (GetVerboseLevel()>1) G4cout << GetName() << "::FillRandomBuffer" << G4endl;
 
  rndm.resize(nFinal-2,0.); // Final states generated in sorted order
  std::generate(rndm.begin(), rndm.end(), uniformRand);
  std::sort(rndm.begin(), rndm.end());
  if (GetVerboseLevel()>2) PrintVector(rndm, "rndm", G4cout);
}

References G4cout, G4endl, G4INCL::PhaseSpaceGenerator::generate(), G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), nFinal, G4VHadDecayAlgorithm::PrintVector(), rndm, and anonymous_namespace{G4HadPhaseSpaceGenbod.cc}::uniformRand().

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

GenerateMomenta()

void G4HadPhaseSpaceGenbod::GenerateMomenta ( const std::vector< G4double > &  masses, std::vector< G4LorentzVector > &  finalState  )

protected

Definition at line 180 of file G4HadPhaseSpaceGenbod.cc.

                                                {
  if (GetVerboseLevel()>1) G4cout << GetName() << "::GenerateMomenta" << G4endl;
 
  finalState.resize(nFinal);    // Preallocate vectors for convenience below
 
  for (size_t i=0; i<nFinal; i++) {
    AccumulateFinalState(i, masses, finalState);
    if (GetVerboseLevel()>2)
      G4cout << " finalState[" << i << "] " << finalState[i] << G4endl;
  }
}

References AccumulateFinalState(), G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), and nFinal.

Referenced by GenerateMultiBody().

GenerateMultiBody()

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

protectedvirtual

Implements G4VHadDecayAlgorithm.

Definition at line 58 of file G4HadPhaseSpaceGenbod.cc.

                                                  {
  if (GetVerboseLevel()) G4cout << GetName() << "::GenerateMultiBody" << G4endl;
 
  finalState.clear();
 
  Initialize(initialMass, masses);
 
  const G4int maxNumberOfLoops = 10000;
  nTrials = 0;
  do {              // Apply accept/reject to get distribution
    ++nTrials;
    FillRandomBuffer();
    FillEnergySteps(initialMass, masses);
  } while ( (!AcceptEvent()) && nTrials < maxNumberOfLoops );  /* Loop checking, 02.11.2015, A.Ribon */
  if ( nTrials >= maxNumberOfLoops ) {
    G4ExceptionDescription ed;
    ed << " Failed sampling after maxNumberOfLoops attempts : forced exit" << G4endl;
    G4Exception( " G4HadPhaseSpaceGenbod::GenerateMultiBody ", "HAD_GENBOD_001", FatalException, ed );
  }
  GenerateMomenta(masses, finalState);
}

References AcceptEvent(), FatalException, FillEnergySteps(), FillRandomBuffer(), G4cout, G4endl, G4Exception(), GenerateMomenta(), G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), Initialize(), and nTrials.

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 AcceptEvent(), AccumulateFinalState(), G4CascadeFinalStateAlgorithm::ChooseGenerators(), ComputeWeight(), ComputeWeightScale(), G4CascadeFinalStateAlgorithm::Configure(), G4CascadeFinalStateAlgorithm::FillDirections(), G4CascadeFinalStateAlgorithm::FillDirManyBody(), G4CascadeFinalStateAlgorithm::FillDirThreeBody(), FillEnergySteps(), G4CascadeFinalStateAlgorithm::FillMagnitudes(), FillRandomBuffer(), G4CascadeFinalStateAlgorithm::FillUsingKopylov(), G4HadDecayGenerator::G4HadDecayGenerator(), G4VHadDecayAlgorithm::Generate(), G4CascadeFinalStateAlgorithm::GenerateCosTheta(), GenerateMomenta(), G4CascadeFinalStateAlgorithm::GenerateMultiBody(), GenerateMultiBody(), G4HadPhaseSpaceKopylov::GenerateMultiBody(), G4HadPhaseSpaceNBodyAsai::GenerateMultiBody(), G4CascadeFinalStateAlgorithm::GenerateTwoBody(), G4HadDecayGenerator::GetAlgorithmName(), 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 AcceptEvent(), AccumulateFinalState(), G4CascadeFinalStateAlgorithm::ChooseGenerators(), ComputeWeight(), ComputeWeightScale(), G4CascadeFinalStateAlgorithm::Configure(), G4CascadeFinalStateAlgorithm::FillDirections(), G4CascadeFinalStateAlgorithm::FillDirManyBody(), G4CascadeFinalStateAlgorithm::FillDirThreeBody(), FillEnergySteps(), G4CascadeFinalStateAlgorithm::FillMagnitudes(), FillRandomBuffer(), G4CascadeFinalStateAlgorithm::FillUsingKopylov(), G4CascadeFinalStateAlgorithm::GenerateCosTheta(), GenerateMomenta(), G4CascadeFinalStateAlgorithm::GenerateMultiBody(), GenerateMultiBody(), G4HadPhaseSpaceKopylov::GenerateMultiBody(), G4HadPhaseSpaceNBodyAsai::GenerateMultiBody(), G4CascadeFinalStateAlgorithm::GenerateTwoBody(), G4VHadPhaseSpaceAlgorithm::GenerateTwoBody(), Initialize(), G4CascadeFinalStateAlgorithm::satisfyTriangle(), and G4CascadeFinalStateAlgorithm::SaveKinematics().

Initialize()

void G4HadPhaseSpaceGenbod::Initialize ( G4double  initialMass, const std::vector< G4double > &  masses  )

protected

Definition at line 83 of file G4HadPhaseSpaceGenbod.cc.

                                                                    {
  if (GetVerboseLevel()>1) G4cout << GetName() << "::Initialize" << G4endl;
 
  nFinal = masses.size();
  msum.resize(nFinal, 0.);      // Initialize buffers for filling
  msq.resize(nFinal, 0.);
 
  std::partial_sum(masses.begin(), masses.end(), msum.begin());
  std::transform(masses.begin(), masses.end(), masses.begin(), msq.begin(),
         std::multiplies<G4double>());
  totalMass  = msum.back();
  massExcess = initialMass - totalMass;
 
  if (GetVerboseLevel()>2) {
    PrintVector(msum, "msum", G4cout);
    PrintVector(msq, "msq", G4cout);
    G4cout << " totalMass " << totalMass << " massExcess " << massExcess
       << G4endl;
  }
 
  ComputeWeightScale(masses);
}

References ComputeWeightScale(), G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), massExcess, msq, msum, nFinal, G4VHadDecayAlgorithm::PrintVector(), totalMass, and G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform().

Referenced by GenerateMultiBody().

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 FillEnergySteps(), FillRandomBuffer(), G4HadPhaseSpaceNBodyAsai::GenerateMultiBody(), 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 ComputeWeightScale(), FillEnergySteps(), G4CascadeFinalStateAlgorithm::FillUsingKopylov(), G4HadPhaseSpaceKopylov::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 G4HadPhaseSpaceKopylov::GenerateMultiBody(), G4HadPhaseSpaceNBodyAsai::GenerateMultiBody(), and G4VHadPhaseSpaceAlgorithm::GenerateTwoBody().

Field Documentation

massExcess

G4double G4HadPhaseSpaceGenbod::massExcess

private

Definition at line 71 of file G4HadPhaseSpaceGenbod.hh.

Referenced by ComputeWeightScale(), FillEnergySteps(), and Initialize().

meff

std::vector<G4double> G4HadPhaseSpaceGenbod::meff

private

Definition at line 78 of file G4HadPhaseSpaceGenbod.hh.

Referenced by AccumulateFinalState(), and FillEnergySteps().

msq

std::vector<G4double> G4HadPhaseSpaceGenbod::msq

private

Definition at line 76 of file G4HadPhaseSpaceGenbod.hh.

Referenced by Initialize().

msum

std::vector<G4double> G4HadPhaseSpaceGenbod::msum

private

Definition at line 75 of file G4HadPhaseSpaceGenbod.hh.

Referenced by ComputeWeightScale(), FillEnergySteps(), and Initialize().

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

nFinal

size_t G4HadPhaseSpaceGenbod::nFinal

private

Definition at line 69 of file G4HadPhaseSpaceGenbod.hh.

Referenced by AccumulateFinalState(), ComputeWeightScale(), FillEnergySteps(), FillRandomBuffer(), GenerateMomenta(), and Initialize().

nTrials

G4int G4HadPhaseSpaceGenbod::nTrials

private

Definition at line 73 of file G4HadPhaseSpaceGenbod.hh.

Referenced by AcceptEvent(), and GenerateMultiBody().

pd

std::vector<G4double> G4HadPhaseSpaceGenbod::pd

private

Definition at line 79 of file G4HadPhaseSpaceGenbod.hh.

Referenced by AccumulateFinalState(), ComputeWeight(), and FillEnergySteps().

rndm

std::vector<G4double> G4HadPhaseSpaceGenbod::rndm

private

Definition at line 77 of file G4HadPhaseSpaceGenbod.hh.

Referenced by FillEnergySteps(), and FillRandomBuffer().

totalMass

G4double G4HadPhaseSpaceGenbod::totalMass

private

Definition at line 70 of file G4HadPhaseSpaceGenbod.hh.

Referenced by Initialize().

verboseLevel

G4int G4VHadDecayAlgorithm::verboseLevel

privateinherited

Definition at line 86 of file G4VHadDecayAlgorithm.hh.

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

weightMax

G4double G4HadPhaseSpaceGenbod::weightMax

private

Definition at line 72 of file G4HadPhaseSpaceGenbod.hh.

Referenced by ComputeWeight(), and ComputeWeightScale().

---

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

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