G4HadDecayGenerator Class Reference

#include <G4HadDecayGenerator.hh>

Inheritance diagram for G4HadDecayGenerator:

Public Types
enum	Algorithm { NONE =0 , Kopylov =1 , GENBOD =2 , NBody =3 }

Public Member Functions
	G4HadDecayGenerator (Algorithm alg=Kopylov, G4int verbose=0)
	G4HadDecayGenerator (G4VHadDecayAlgorithm *alg, G4int verbose=0)
virtual	~G4HadDecayGenerator ()
void	SetVerboseLevel (G4int verbose)
const G4String &	GetAlgorithmName () const
G4bool	Generate (G4double initialMass, const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState)
G4bool	Generate (const G4ParticleDefinition *initialPD, const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState)
G4bool	Generate (const G4LorentzVector &initialState, const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState)

Protected Member Functions
G4bool	GenerateOneBody (G4double initialMass, const std::vector< G4double > &masses, std::vector< G4LorentzVector > &finalState) const
void	ReportInvalidAlgorithm (Algorithm alg) const
void	ReportMissingAlgorithm () const
void	UseAlgorithm (G4VHadDecayAlgorithm *alg)

Protected Attributes
G4int	verboseLevel
G4VHadDecayAlgorithm *	theAlgorithm

Detailed Description

Definition at line 49 of file G4HadDecayGenerator.hh.

Member Enumeration Documentation

Algorithm

enum G4HadDecayGenerator::Algorithm

Enumerator
NONE
Kopylov
GENBOD
NBody

Definition at line 52 of file G4HadDecayGenerator.hh.

{ NONE=0, Kopylov=1, GENBOD=2, NBody=3 };

Constructor & Destructor Documentation

G4HadDecayGenerator() [1/2]

G4HadDecayGenerator::G4HadDecayGenerator	(	Algorithm	alg = Kopylov,
		G4int	verbose = 0 )

Definition at line 55 of file G4HadDecayGenerator.cc.

  : verboseLevel(verbose), theAlgorithm(0) {
  switch (alg) {
  case Kopylov: theAlgorithm = new G4HadPhaseSpaceKopylov(verboseLevel); break;
  case GENBOD: theAlgorithm = new G4HadPhaseSpaceGenbod(verboseLevel); break;
  case NBody: theAlgorithm = new G4HadPhaseSpaceNBodyAsai(verboseLevel); break;
  case NONE: theAlgorithm = 0; break;   // User may explicitly set no algorithm
  default: ReportInvalidAlgorithm(alg);
  }
 
  if (verboseLevel) {
    G4cout << " >>> G4HadDecayGenerator";
    if (theAlgorithm) G4cout << " using " << theAlgorithm->GetName();
    G4cout << G4endl;
  }
}

Referenced by G4CascadeFinalStateGenerator::G4CascadeFinalStateGenerator().

G4HadDecayGenerator() [2/2]

G4HadDecayGenerator::G4HadDecayGenerator	(	G4VHadDecayAlgorithm *	alg,
		G4int	verbose = 0 )

Definition at line 72 of file G4HadDecayGenerator.cc.

  : verboseLevel(verbose), theAlgorithm(alg) {
  if (verboseLevel) {
    G4cout << " >>> G4HadDecayGenerator";
    if (theAlgorithm) G4cout << " using " << theAlgorithm->GetName();
    G4cout << G4endl;
  }
}

~G4HadDecayGenerator()

G4HadDecayGenerator::~G4HadDecayGenerator ( )

virtual

Definition at line 82 of file G4HadDecayGenerator.cc.

                                          {
  delete theAlgorithm;
  theAlgorithm = 0;
}

Member Function Documentation

Generate() [1/3]

G4bool G4HadDecayGenerator::Generate	(	const G4LorentzVector &	initialState,
		const std::vector< G4double > &	masses,
		std::vector< G4LorentzVector > &	finalState )

Definition at line 150 of file G4HadDecayGenerator.cc.

                                                          {
  if (verboseLevel) 
    G4cout << " >>> G4HadDecayGenerator::Generate (frame)" << G4endl;
 
  G4bool good = Generate(initialState.m(), masses, finalState);
  if (good) {
    G4ThreeVector bv = initialState.boostVector();
    for (size_t i=0; i<finalState.size(); i++) {
      finalState[i].boost(bv);
    }
  }
 
  return good;
}

Generate() [2/3]

G4bool G4HadDecayGenerator::Generate	(	const G4ParticleDefinition *	initialPD,
		const std::vector< G4double > &	masses,
		std::vector< G4LorentzVector > &	finalState )

Definition at line 138 of file G4HadDecayGenerator.cc.

                                                           {
  if (verboseLevel) 
    G4cout << " >>> G4HadDecayGenerator::Generate (particle)" << G4endl;
 
  return (initialPD && Generate(initialPD->GetPDGMass(), masses, finalState));
}

Generate() [3/3]

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

Definition at line 120 of file G4HadDecayGenerator.cc.

                                                           {
  if (verboseLevel) 
    G4cout << " >>> G4HadDecayGenerator::Generate (mass)" << G4endl;
 
  if (!theAlgorithm) ReportMissingAlgorithm();
 
  if (masses.size() == 1U)
    return GenerateOneBody(initialMass, masses, finalState);
 
  theAlgorithm->Generate(initialMass, masses, finalState);
  return !finalState.empty();       // Generator failure returns empty state
}

Referenced by Generate(), and Generate().

GenerateOneBody()

G4bool G4HadDecayGenerator::GenerateOneBody ( G4double initialMass, const std::vector< G4double > & masses, std::vector< G4LorentzVector > & finalState ) const

protected

Definition at line 170 of file G4HadDecayGenerator.cc.

                                                      {
  if (verboseLevel>1) 
    G4cout << " >>> G4HadDecayGenerator::GenerateOneBody" << G4endl;
 
  // Initialization and sanity checks
  finalState.clear();
 
  if (masses.size() != 1U) return false;    // Should not have been called
  if (std::fabs(initialMass-masses[0]) > eV) return false;
 
  if (verboseLevel>2) G4cout << " finalState mass = " << masses[0] << G4endl;
 
  finalState.push_back(G4LorentzVector(0.,0.,0.,masses[0]));
  return true;
}

Referenced by Generate().

GetAlgorithmName()

const G4String & G4HadDecayGenerator::GetAlgorithmName

(

)

const

Definition at line 111 of file G4HadDecayGenerator.cc.

                                                            {
  static const G4String& none = "NONE";
  return (theAlgorithm ? theAlgorithm->GetName() : none);
}

ReportInvalidAlgorithm()

void G4HadDecayGenerator::ReportInvalidAlgorithm ( Algorithm alg ) const

protected

Definition at line 90 of file G4HadDecayGenerator.cc.

                                                                    {
  if (verboseLevel) 
    G4cerr << "G4HadDecayGenerator: bad algorithm code " << alg << G4endl;
 
  throw G4HadronicException(__FILE__, __LINE__, "Invalid algorithm code");
}

Referenced by G4HadDecayGenerator().

ReportMissingAlgorithm()

void G4HadDecayGenerator::ReportMissingAlgorithm ( ) const

protected

Definition at line 97 of file G4HadDecayGenerator.cc.

                                                       {
  if (verboseLevel) 
    G4cerr << "G4HadDecayGenerator: no algorithm specified" << G4endl;
 
  throw G4HadronicException(__FILE__, __LINE__, "Null algorithm pointer");
}

Referenced by Generate().

SetVerboseLevel()

void G4HadDecayGenerator::SetVerboseLevel

(

G4int

verbose

)

Definition at line 106 of file G4HadDecayGenerator.cc.

                                                       {
  verboseLevel = verbose;
  if (theAlgorithm) theAlgorithm->SetVerboseLevel(verbose);
}

UseAlgorithm()

void G4HadDecayGenerator::UseAlgorithm ( G4VHadDecayAlgorithm * alg )

inlineprotected

Definition at line 100 of file G4HadDecayGenerator.hh.

{ theAlgorithm = alg; }

Member Data Documentation

theAlgorithm

G4VHadDecayAlgorithm* G4HadDecayGenerator::theAlgorithm

protected

Definition at line 103 of file G4HadDecayGenerator.hh.

Referenced by G4CascadeFinalStateGenerator::Configure(), G4HadDecayGenerator(), G4HadDecayGenerator(), Generate(), GetAlgorithmName(), SetVerboseLevel(), UseAlgorithm(), and ~G4HadDecayGenerator().

verboseLevel

G4int G4HadDecayGenerator::verboseLevel

protected

Definition at line 102 of file G4HadDecayGenerator.hh.

Referenced by G4CascadeFinalStateGenerator::Configure(), G4HadDecayGenerator(), G4HadDecayGenerator(), Generate(), Generate(), Generate(), GenerateOneBody(), ReportInvalidAlgorithm(), ReportMissingAlgorithm(), and SetVerboseLevel().

---

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

• G4HadDecayGenerator.hh
• G4HadDecayGenerator.cc