G4HadPhaseSpaceNBodyAsai Class Reference

#include <G4HadPhaseSpaceNBodyAsai.hh>

Inheritance diagram for G4HadPhaseSpaceNBodyAsai:

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

Protected Member Functions
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 G4HadPhaseSpaceNBodyAsai.hh.

Constructor & Destructor Documentation

G4HadPhaseSpaceNBodyAsai()

G4HadPhaseSpaceNBodyAsai::G4HadPhaseSpaceNBodyAsai ( G4int  verbose = 0 )

inline

Definition at line 39 of file G4HadPhaseSpaceNBodyAsai.hh.

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

~G4HadPhaseSpaceNBodyAsai()

virtual G4HadPhaseSpaceNBodyAsai::~G4HadPhaseSpaceNBodyAsai ( )

inlinevirtual

Definition at line 41 of file G4HadPhaseSpaceNBodyAsai.hh.

{;}

Member Function Documentation

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 G4HadPhaseSpaceNBodyAsai::GenerateMultiBody ( G4double  initialMass, const std::vector< G4double > &  masses, std::vector< G4LorentzVector > &  finalState  )

protectedvirtual

Implements G4VHadDecayAlgorithm.

Definition at line 50 of file G4HadPhaseSpaceNBodyAsai.cc.

                                                  {
  if (GetVerboseLevel()) G4cout << GetName() << "::GenerateMultiBody" << G4endl;
 
  finalState.clear();
 
  //daughters' mass
  G4int numberOfDaughters = masses.size();
  G4double sumofmasses =
    std::accumulate(masses.begin(), masses.end(), 0.);
  
  //Calculate daughter momentum
  std::vector<G4double> daughtermomentum(numberOfDaughters);
  std::vector<G4double> sm(numberOfDaughters);
  G4double tmas;
  G4double weight = 1.0;
  G4int numberOfTry = 0; 
  G4int i;
 
  std::vector<G4double> rd(numberOfDaughters);
  do {
    //Generate random number in descending order
    rd[0] = 1.0;
    std::generate(rd.begin()+1, rd.end(), uniformRand);
    std::sort(rd.begin(), rd.end(), std::greater<G4double>());
 
    if (GetVerboseLevel()>1) PrintVector(rd,"rd",G4cout);
 
    //calcurate virtual mass 
    tmas = initialMass -  sumofmasses;
    G4double temp = sumofmasses; 
    for(i =0; i < numberOfDaughters; i++) {
      sm[i] = rd[i]*tmas + temp;
      temp -= masses[i];
      if (GetVerboseLevel()>1) {
        G4cout << i << " random number:" << rd[i]
           << " virtual mass:" << sm[i]/GeV << " GeV/c2" <<G4endl; 
      }
    }
 
    //Calculate daughter momentum
    weight = 1.0;
    i = numberOfDaughters-1;
    daughtermomentum[i] = TwoBodyMomentum(sm[i-1],masses[i-1],sm[i]);
    if (GetVerboseLevel()>1) {
      G4cout << " daughter " << i << ": momentum "
         << daughtermomentum[i]/GeV << " GeV/c" <<G4endl;
    }
    for(i =numberOfDaughters-2; i>=0; i--) {
      // calculate 
      daughtermomentum[i] = TwoBodyMomentum(sm[i],masses[i],sm[i+1]);
      if(daughtermomentum[i] < 0.0) {
        // !!! illegal momentum !!!
        if (GetVerboseLevel()>0) {
          G4cout << "G4HadPhaseSpaceNBodyAsai::Generate "
         << " can not calculate daughter momentum "
         << "\n initialMass " << initialMass/GeV << " GeV/c2"
         << "\n daughter " << i << ": mass "
         << masses[i]/GeV << " GeV/c2; momentum "
         << daughtermomentum[i]/GeV << " GeV/c" << G4endl;
        }
    return;         // Error detection
      }
 
      // calculate weight of this events
      weight *= daughtermomentum[i]/sm[i];
      if (GetVerboseLevel()>1) {
    G4cout << " daughter " << i << ": momentum "
           << daughtermomentum[i]/GeV << " GeV/c" <<G4endl;
      }
    }
    if (GetVerboseLevel()>1) {
      G4cout << " weight: " << weight <<G4endl;
    }
    
    // exit if number of Try exceeds 100
    if (numberOfTry++ > 100) {
      if (GetVerboseLevel()>0) {
        G4cout << "G4HadPhaseSpaceNBodyAsai::Generate "
           << " can not determine Decay Kinematics " << G4endl;
      }
      return;           // Error detection
    }
  } while (weight > G4UniformRand());  /* Loop checking, 02.11.2015, A.Ribon */
 
  if (GetVerboseLevel()>1) {
      G4cout << "Start calculation of daughters momentum vector "<<G4endl;
  }
  
  G4double beta;
 
  finalState.resize(numberOfDaughters);
 
  i = numberOfDaughters-2;
 
  G4ThreeVector direction = UniformVector(daughtermomentum[i]);
 
  finalState[i].setVectM(direction, masses[i]);
  finalState[i+1].setVectM(-direction, masses[i+1]);
 
  for (i = numberOfDaughters-3;  i >= 0; i--) {
    direction = UniformVector();
 
    //create daughter particle
    finalState[i].setVectM(-daughtermomentum[i]*direction, masses[i]);
 
    // boost already created particles 
    beta = daughtermomentum[i];
    beta /= std::sqrt(beta*beta + sm[i+1]*sm[i+1]);
    for (G4int j = i+1; j<numberOfDaughters; j++) {
      finalState[j].boost(beta*direction);
    }
  }
}

References anonymous_namespace{G4PionRadiativeDecayChannel.cc}::beta, G4cout, G4endl, G4UniformRand, G4INCL::PhaseSpaceGenerator::generate(), G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), GeV, G4VHadDecayAlgorithm::PrintVector(), G4InuclParticleNames::sm, G4VHadDecayAlgorithm::TwoBodyMomentum(), anonymous_namespace{G4HadPhaseSpaceNBodyAsai.cc}::uniformRand(), 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(), G4HadPhaseSpaceKopylov::GenerateMultiBody(), 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(), G4HadPhaseSpaceKopylov::GenerateMultiBody(), 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(), 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(), G4HadPhaseSpaceKopylov::GenerateMultiBody(), 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(), 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/G4HadPhaseSpaceNBodyAsai.hh
• source/processes/hadronic/util/src/G4HadPhaseSpaceNBodyAsai.cc