#include <G4CascadeFinalStateAlgorithm.hh>

Inheritance diagram for G4CascadeFinalStateAlgorithm:

Public Member Functions
	G4CascadeFinalStateAlgorithm ()

virtual	~G4CascadeFinalStateAlgorithm ()

virtual void	SetVerboseLevel (G4int verbose)

void	Configure (G4InuclElementaryParticle bullet, G4InuclElementaryParticle target, const std::vector< G4int > &particle_kinds)

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)

G4int	GetVerboseLevel () const

const G4String &	GetName () const

Protected Member Functions
virtual void	GenerateTwoBody (G4double initialMass, const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState)

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

void	SaveKinematics (G4InuclElementaryParticle bullet, G4InuclElementaryParticle target)

void	ChooseGenerators (G4int is, G4int fs)

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

G4bool	satisfyTriangle (const std::vector< G4double > &pmod) const

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

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

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

G4double	GenerateCosTheta (G4int ptype, G4double pmod) const

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

G4double	BetaKopylov (G4int K) const

Protected Member Functions inherited from G4VHadDecayAlgorithm
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 49 of file G4CascadeFinalStateAlgorithm.hh.

Constructor & Destructor Documentation

G4CascadeFinalStateAlgorithm::G4CascadeFinalStateAlgorithm ( )

Definition at line 72 of file G4CascadeFinalStateAlgorithm.cc.

73 : G4VHadDecayAlgorithm("G4CascadeFinalStateAlgorithm"),

74 momDist(0), angDist(0), multiplicity(0), bullet_ekin(0.) {;}

G4VHadDecayAlgorithm::G4VHadDecayAlgorithm

G4VHadDecayAlgorithm(const G4String &algName, G4int verbose=0)

Definition: G4VHadDecayAlgorithm.hh:45

G4CascadeFinalStateAlgorithm::~G4CascadeFinalStateAlgorithm ( )

virtual

Definition at line 76 of file G4CascadeFinalStateAlgorithm.cc.

76 {;}

Member Function Documentation

G4double G4CascadeFinalStateAlgorithm::BetaKopylov ( G4int K ) const

protected

Definition at line 504 of file G4CascadeFinalStateAlgorithm.cc.

References G4UniformRand, G4Pow::GetInstance(), N, and G4Pow::powN().

Referenced by FillUsingKopylov().

                                                                 {
   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;
   do {
     chi = G4UniformRand();
     F = std::sqrt(g4pow->powN(chi,N)*(1.-chi));      
   } while ( Fmax*G4UniformRand() > F);  
   return chi;
 }

void G4CascadeFinalStateAlgorithm::ChooseGenerators	(	G4int	is,
		G4int	fs
	)

protected

Definition at line 133 of file G4CascadeFinalStateAlgorithm.cc.

References G4cout, G4endl, G4MultiBodyMomentumDist::GetDist(), G4TwoBodyAngularDist::GetDist(), G4VMultiBodyMomDst::GetName(), G4VTwoBodyAngDst::GetName(), G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), and G4CascadeParameters::usePhaseSpace().

Referenced by Configure().

                                                                       {
   if (GetVerboseLevel()>1) 
     G4cout << " >>> " << GetName() << "::ChooseGenerators"
        << " is " << is << " fs " << fs << G4endl;
 
   // Get generators for momentum and angle
   if (G4CascadeParameters::usePhaseSpace()) momDist = 0;
   else momDist = G4MultiBodyMomentumDist::GetDist(is, multiplicity);
 
   if (fs > 0 && multiplicity == 2) {
     G4int kw = (fs==is) ? 1 : 2;
     angDist = G4TwoBodyAngularDist::GetDist(is, fs, kw);
   } else if (multiplicity == 3) {
     angDist = G4TwoBodyAngularDist::GetDist(is);
   } else {
     angDist = 0;
   }
 
   if (GetVerboseLevel()>1) {
     G4cout << " " << (momDist?momDist->GetName():"") << " "
        << (angDist?angDist->GetName():"") << G4endl;
   }
 }

void G4CascadeFinalStateAlgorithm::Configure	(	G4InuclElementaryParticle *	bullet,
		G4InuclElementaryParticle *	target,
		const std::vector< G4int > &	particle_kinds
	)

Definition at line 89 of file G4CascadeFinalStateAlgorithm.cc.

References ChooseGenerators(), G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), SaveKinematics(), and G4InuclElementaryParticle::type().

Referenced by G4CascadeFinalStateGenerator::Configure().

                                               {
   if (GetVerboseLevel()>1)
     G4cout << " >>> " << GetName() << "::Configure" << G4endl;
 
   // Identify initial and final state (if two-body) for algorithm selection
   multiplicity = particle_kinds.size();
   G4int is = bullet->type() * target->type();
   G4int fs = (multiplicity==2) ? particle_kinds[0]*particle_kinds[1] : 0;
 
   ChooseGenerators(is, fs);
 
   // Save kinematics for use with distributions
   SaveKinematics(bullet, target);
 
   // Save particle types for use with distributions
   kinds = particle_kinds;
 }

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

protected

Definition at line 310 of file G4CascadeFinalStateAlgorithm.cc.

References FillDirManyBody(), FillDirThreeBody(), G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), and G4VHadDecayAlgorithm::GetVerboseLevel().

Referenced by GenerateMultiBody().

                                                    {
   if (GetVerboseLevel()>1) 
     G4cout << " >>> " << GetName() << "::FillDirections" << G4endl;
 
   finalState.clear();           // Initialization and sanity check
   if ((G4int)modules.size() != multiplicity) return;
 
   // Different order of processing for three vs. N body
   if (multiplicity == 3)
     FillDirThreeBody(initialMass, masses, finalState);
   else
     FillDirManyBody(initialMass, masses, finalState);
 }

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

protected

Definition at line 359 of file G4CascadeFinalStateAlgorithm.cc.

References G4cout, G4endl, GenerateCosTheta(), G4InuclSpecialFunctions::generateWithFixedTheta(), G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), CLHEP::HepLorentzVector::rho(), G4LorentzConvertor::rotate(), and CLHEP::HepLorentzVector::set().

Referenced by FillDirections().

                                                 {
   if (GetVerboseLevel()>1) 
     G4cout << " >>> " << GetName() << "::FillDirManyBody" << G4endl;
 
   // Fill all but the last two particles randomly
   G4double costh = 0.;
 
   finalState.resize(multiplicity);
 
   for (G4int i=0; i<multiplicity-2; i++) {
     costh = GenerateCosTheta(kinds[i], modules[i]);
     finalState[i] = generateWithFixedTheta(costh, modules[i], masses[i]);
     finalState[i] = toSCM.rotate(finalState[i]);    // Align target axis
   }
 
   // Total momentum so far, to compute recoil of last two particles
   G4LorentzVector psum =
     std::accumulate(finalState.begin(), finalState.end()-2, G4LorentzVector());
   G4double pmod = psum.rho();
 
   costh = -0.5 * (pmod*pmod +
           modules[multiplicity-2]*modules[multiplicity-2] -
           modules[multiplicity-1]*modules[multiplicity-1])
     / pmod / modules[multiplicity-2];
 
   if (GetVerboseLevel() > 2) G4cout << " ct last " << costh << G4endl;
 
   if (std::fabs(costh) >= maxCosTheta) {  // Bad kinematics; abort generation
     finalState.clear();
     return;
   }
 
   // Report success
   if (GetVerboseLevel()>2) G4cout << " ok for mult " << multiplicity << G4endl;
 
   // First particle is at fixed angle to recoil system
   finalState[multiplicity-2] =
     generateWithFixedTheta(costh, modules[multiplicity-2],
                masses[multiplicity-2]);
   finalState[multiplicity-2] = toSCM.rotate(psum, finalState[multiplicity-2]);
 
   // Remaining particle is constrained to recoil from entire rest of system
   finalState[multiplicity-1].set(0.,0.,0.,initialMass);
   finalState[multiplicity-1] -= psum + finalState[multiplicity-2];
 }

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

protected

Definition at line 326 of file G4CascadeFinalStateAlgorithm.cc.

References G4cout, G4endl, GenerateCosTheta(), G4InuclSpecialFunctions::generateWithFixedTheta(), G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), G4LorentzConvertor::rotate(), and CLHEP::HepLorentzVector::set().

Referenced by FillDirections().

                                                  {
   if (GetVerboseLevel()>1) 
     G4cout << " >>> " << GetName() << "::FillDirThreeBody" << G4endl;
 
   finalState.resize(3);
 
   G4double costh = GenerateCosTheta(kinds[2], modules[2]);
   finalState[2] = generateWithFixedTheta(costh, modules[2], masses[2]);
   finalState[2] = toSCM.rotate(finalState[2]);  // Align target axis
 
   // Generate direction of first particle
   costh = -0.5 * (modules[2]*modules[2] + modules[0]*modules[0] -
           modules[1]*modules[1]) / modules[2] / modules[0];
 
   if (std::fabs(costh) >= maxCosTheta) {  // Bad kinematics; abort generation
     finalState.clear();
     return;
   }
 
   // Report success
   if (GetVerboseLevel()>2) G4cout << " ok for mult 3" << G4endl;
 
   // First particle is at fixed angle to recoil system
   finalState[0] = generateWithFixedTheta(costh, modules[0], masses[0]);
   finalState[0] = toSCM.rotate(finalState[2], finalState[0]);
 
   // Remaining particle is constrained to recoil from entire rest of system
   finalState[1].set(0.,0.,0.,initialMass);
   finalState[1] -= finalState[0] + finalState[2];
 }

void G4CascadeFinalStateAlgorithm::FillMagnitudes	(	G4double	initialMass,
		const std::vector< G4double > &	masses
	)

protected

Definition at line 225 of file G4CascadeFinalStateAlgorithm.cc.

References G4cerr, G4cout, G4endl, G4VMultiBodyMomDst::GetMomentum(), G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), and satisfyTriangle().

Referenced by GenerateMultiBody().

                                                                         {
   if (GetVerboseLevel()>1) 
     G4cout << " >>> " << GetName() << "::FillMagnitudes" << G4endl;
 
   modules.clear();      // Initialization and sanity checks
   if (!momDist) return;
 
   modules.resize(multiplicity,0.);  // Pre-allocate to avoid resizing
 
   G4double mass_last = masses.back();
   G4double pmod = 0.;
 
   if (GetVerboseLevel() > 3){
     G4cout << " knd_last " << kinds.back() << " mass_last " 
            << mass_last << G4endl;
   }
 
   G4int itry = -1;
   while (++itry < itry_max) {
     if (GetVerboseLevel() > 3) {
       G4cout << " itry in fillMagnitudes " << itry << G4endl;
     }
 
     G4double eleft = initialMass;
 
     G4int i;    // For access outside of loop
     for (i=0; i < multiplicity-1; i++) {
       pmod = momDist->GetMomentum(kinds[i], bullet_ekin);
 
       if (pmod < small) break;
       eleft -= std::sqrt(pmod*pmod + masses[i]*masses[i]);
 
       if (GetVerboseLevel() > 3) {
     G4cout << " kp " << kinds[i] << " pmod " << pmod
            << " mass2 " << masses[i]*masses[i] << " eleft " << eleft
            << "\n x1 " << eleft - mass_last << G4endl;
       }
 
       if (eleft <= mass_last) break;
 
       modules[i] = pmod;
     }
 
     if (i < multiplicity-1) continue;   // Failed to generate full kinematics
 
     G4double plast = eleft * eleft - masses.back()*masses.back();
     if (GetVerboseLevel() > 2) G4cout << " plast ** 2 " << plast << G4endl;
     
     if (plast <= small) continue;   // Not enough momentum left over
 
     plast = std::sqrt(plast);       // Final momentum is what's left over
     modules.back() = plast;
     
     if (multiplicity > 3 || satisfyTriangle(modules)) break;    // Successful
   } // while (itry < itry_max)
 
   if (itry >= itry_max) {       // Too many attempts
     if (GetVerboseLevel() > 2)
       G4cerr << " Unable to generate momenta for multiplicity "
          << multiplicity << G4endl;
 
     modules.clear();        // Something went wrong, throw away partial
   }
 }

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

protected

Definition at line 461 of file G4CascadeFinalStateAlgorithm.cc.

References BetaKopylov(), CLHEP::HepLorentzVector::boost(), CLHEP::HepLorentzVector::boostVector(), G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), N, CLHEP::Hep3Vector::setRThetaPhi(), CLHEP::HepLorentzVector::setVectM(), G4VHadDecayAlgorithm::TwoBodyMomentum(), G4VHadDecayAlgorithm::UniformPhi(), and G4VHadDecayAlgorithm::UniformTheta().

Referenced by GenerateMultiBody().

                                                  {
   if (GetVerboseLevel()>2)
     G4cout << " >>> " << GetName() << "::FillUsingKopylov" << 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 Mass = initialMass;
   G4double T = Mass-mtot;
   G4double recoilMass = 0.0;
   G4ThreeVector momV, boostV;       // Buffers to reduce memory churn
   G4LorentzVector recoil(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.;
     
     recoilMass = mu + T;
 
     boostV = recoil.boostVector();  // Previous system's rest frame
     
     // Create momentum with a random direction isotropically distributed
     // FIXME:  Should theta distribution should use Bertini fit function?
     momV.setRThetaPhi(TwoBodyMomentum(Mass,masses[k],recoilMass),
               UniformTheta(), UniformPhi());
     
     finalState[k].setVectM(momV,masses[k]);
     recoil.setVectM(-momV,recoilMass);
 
     finalState[k].boost(boostV);
     recoil.boost(boostV);
     Mass = recoilMass;
   }
   
   finalState[0] = recoil;
 }

G4double G4CascadeFinalStateAlgorithm::GenerateCosTheta	(	G4int	ptype,
		G4double	pmod
	)		const

protected

Definition at line 410 of file G4CascadeFinalStateAlgorithm.cc.

References G4cout, G4endl, G4VTwoBodyAngDst::GetCosTheta(), G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), and G4InuclSpecialFunctions::inuclRndm().

Referenced by FillDirManyBody(), and FillDirThreeBody().

                                                    {
   if (GetVerboseLevel() > 2) {
     G4cout << " >>> " << GetName() << "::GenerateCosTheta " << ptype
        << " " << pmod << G4endl;
   }
 
   if (multiplicity == 3) {      // Use distribution for three-body
     return angDist->GetCosTheta(bullet_ekin, ptype);
   }
 
   // Throw multi-body distribution
   G4double p0 = ptype<3 ? 0.36 : 0.25;  // Nucleon vs. everything else
   G4double alf = 1.0 / p0 / (p0 - (pmod+p0)*std::exp(-pmod / p0));
 
   G4double sinth = 2.0;
 
   G4int itry1 = -1;
   while (std::fabs(sinth) > maxCosTheta && ++itry1 < itry_max) {
     G4double s1 = pmod * inuclRndm();
     G4double s2 = alf * oneOverE * p0 * inuclRndm();
     G4double salf = s1 * alf * std::exp(-s1 / p0);
     if (GetVerboseLevel() > 3) {
       G4cout << " s1 * alf * std::exp(-s1 / p0) " << salf
          << " s2 " << s2 << G4endl;
     }
     
     if (salf > s2) sinth = s1 / pmod;
   }
   
   if (GetVerboseLevel() > 3)
     G4cout << " itry1 " << itry1 << " sinth " << sinth << G4endl;
   
   if (itry1 == itry_max) {
     if (GetVerboseLevel() > 2)
       G4cout << " high energy angles generation: itry1 " << itry1 << G4endl;
     
     sinth = 0.5 * inuclRndm();
   }
 
   // Convert generated sin(theta) to cos(theta) with random sign
   G4double costh = std::sqrt(1.0 - sinth * sinth);
   if (inuclRndm() > 0.5) costh = -costh;
 
   return costh;
 }

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

protectedvirtual

Implements G4VHadDecayAlgorithm.

Definition at line 202 of file G4CascadeFinalStateAlgorithm.cc.

References FillDirections(), FillMagnitudes(), FillUsingKopylov(), G4cout, G4endl, G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), and G4CascadeParameters::usePhaseSpace().

                                                   {
   if (GetVerboseLevel()>1) 
     G4cout << " >>> " << GetName() << "::GenerateMultiBody" << G4endl;
 
   if (G4CascadeParameters::usePhaseSpace()) {
     FillUsingKopylov(initialMass, masses, finalState);
     return;
   }
 
   finalState.clear();       // Initialization and sanity checks
   if (multiplicity < 3) return;
   if (!momDist) return;
 
   G4int itry = -1;
   while ((G4int)finalState.size() != multiplicity && ++itry < itry_max) {
     FillMagnitudes(initialMass, masses);
     FillDirections(initialMass, masses, finalState);
   }
 }

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

protectedvirtual

Implements G4VHadDecayAlgorithm.

Definition at line 161 of file G4CascadeFinalStateAlgorithm.cc.

References G4cout, G4endl, G4UniformRand, G4VTwoBodyAngDst::GetCosTheta(), G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), G4LorentzConvertor::rotate(), CLHEP::Hep3Vector::setRThetaPhi(), G4VHadDecayAlgorithm::TwoBodyMomentum(), G4VHadDecayAlgorithm::UniformPhi(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

                                                 {
   if (GetVerboseLevel()>1) 
     G4cout << " >>> " << GetName() << "::GenerateTwoBody" << G4endl;
 
   finalState.clear();       // Initialization and sanity checks
 
   if (multiplicity != 2) return;
 
   // Generate momentum vector in CMS for back-to-back particles
   G4double pscm = TwoBodyMomentum(initialMass, masses[0], masses[1]);
 
   G4double costh = angDist ? angDist->GetCosTheta(bullet_ekin, pscm)
                            : (2.*G4UniformRand() - 1.);
 
   mom.setRThetaPhi(pscm, std::acos(costh), UniformPhi());
 
   if (GetVerboseLevel()>3) {        // Copied from old G4EPCollider
     G4cout << " Particle kinds = " << kinds[0] << " , " << kinds[1]
        << "\n pmod " << pscm
        << "\n before rotation px " << mom.x() << " py " << mom.y()
        << " pz " << mom.z() << G4endl;
   }
 
   finalState.resize(2);             // Allows filling by index
 
   finalState[0].setVectM(mom, masses[0]);
   finalState[0] = toSCM.rotate(finalState[0]);
 
   if (GetVerboseLevel()>3) {        // Copied from old G4EPCollider
     G4cout << " after rotation px " << finalState[0].x() << " py "
        << finalState[0].y() << " pz " << finalState[0].z() << G4endl;
   }
 
   finalState[1].setVectM(-finalState[0].vect(), masses[1]);
 }

G4bool G4CascadeFinalStateAlgorithm::satisfyTriangle ( const std::vector< G4double > & pmod ) const

protected

Definition at line 293 of file G4CascadeFinalStateAlgorithm.cc.

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

Referenced by FillMagnitudes().

                                                        {
   if (GetVerboseLevel() > 3) 
     G4cout << " >>> " << GetName() << "::satisfyTriangle" << G4endl;
 
   return ( (pmod.size() != 3) ||
        !(pmod[0] < std::fabs(pmod[1] - pmod[2]) ||
          pmod[0] > pmod[1] + pmod[2] ||
          pmod[1] < std::fabs(pmod[0] - pmod[2]) ||
          pmod[1] > pmod[0] + pmod[2] ||
          pmod[2] < std::fabs(pmod[0] - pmod[1]) ||
          pmod[2] > pmod[1] + pmod[0])
        );
 }

void G4CascadeFinalStateAlgorithm::SaveKinematics	(	G4InuclElementaryParticle *	bullet,
		G4InuclElementaryParticle *	target
	)

protected

Definition at line 112 of file G4CascadeFinalStateAlgorithm.cc.

References G4cout, G4endl, G4LorentzConvertor::getKinEnergyInTheTRS(), G4VHadDecayAlgorithm::GetName(), G4VHadDecayAlgorithm::GetVerboseLevel(), G4InuclElementaryParticle::nucleon(), G4LorentzConvertor::setBullet(), G4LorentzConvertor::setTarget(), and G4LorentzConvertor::toTheCenterOfMass().

Referenced by Configure().

                                               {
   if (GetVerboseLevel()>1) 
     G4cout << " >>> " << GetName() << "::SaveKinematics" << G4endl;
 
   if (target->nucleon()) {  // Which particle originated in nucleus?
     toSCM.setBullet(bullet);
     toSCM.setTarget(target);
   } else {
     toSCM.setBullet(target);
     toSCM.setTarget(bullet);
   }
 
   toSCM.toTheCenterOfMass();
 
   bullet_ekin = toSCM.getKinEnergyInTheTRS();
 }

void G4CascadeFinalStateAlgorithm::SetVerboseLevel ( G4int verbose )

virtual

Reimplemented from G4VHadDecayAlgorithm.

Definition at line 78 of file G4CascadeFinalStateAlgorithm.cc.

References G4LorentzConvertor::setVerbose(), G4VHadDecayAlgorithm::SetVerboseLevel(), G4MultiBodyMomentumDist::setVerboseLevel(), and G4TwoBodyAngularDist::setVerboseLevel().

                                                                 {
   G4VHadDecayAlgorithm::SetVerboseLevel(verbose);
   G4MultiBodyMomentumDist::setVerboseLevel(verbose);
   G4TwoBodyAngularDist::setVerboseLevel(verbose);
   toSCM.setVerbose(verbose);
 }

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

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation