G4SampleResonance Class Reference

#include <G4SampleResonance.hh>

Public Types
typedef std::map< const G4ParticleDefinition *, G4double, std::less< const G4ParticleDefinition * > >::const_iterator	minMassMapIterator
typedef std::map< const G4ParticleDefinition *, G4double, std::less< const G4ParticleDefinition * > >	minMassMapType
Public Member Functions
G4double	GetMinimumMass (const G4ParticleDefinition *p) const
G4double	SampleMass (const G4double poleMass, const G4double gamma, const G4double minMass, const G4double maxMass) const
G4double	SampleMass (const G4ParticleDefinition *p, const G4double maxMass) const

---

Detailed Description

Definition at line 45 of file G4SampleResonance.hh.

---

Member Typedef Documentation

typedef std::map<const G4ParticleDefinition*, G4double, std::less<const G4ParticleDefinition*> >::const_iterator G4SampleResonance::minMassMapIterator

Definition at line 69 of file G4SampleResonance.hh.

typedef std::map<const G4ParticleDefinition*, G4double, std::less<const G4ParticleDefinition*> > G4SampleResonance::minMassMapType

Definition at line 70 of file G4SampleResonance.hh.

---

Member Function Documentation

G4double G4SampleResonance::GetMinimumMass

(

const G4ParticleDefinition *

p

)

const

Definition at line 46 of file G4SampleResonance.cc.

References DBL_MAX, G4DecayTable::entries(), G4DecayTable::GetDecayChannel(), G4ParticleDefinition::GetPDGMass(), and G4ParticleDefinition::IsShortLived().

Referenced by G4KineticTrack::Decay(), G4KineticTrack::G4KineticTrack(), and SampleMass().

{

        G4double minResonanceMass = DBL_MAX;

        if ( p->IsShortLived() )
        {
                minMassMapIterator iter = minMassCache.find(p);
                if ( iter!=minMassCache.end() )
                {
                        minResonanceMass = (*iter).second;
                }
                else
                {
                        // G4cout << "--> request for " << p->GetParticleName() << G4endl;

                        const G4DecayTable* theDecays = const_cast<G4ParticleDefinition*>(p)->GetDecayTable();
                        const G4int nDecays = theDecays->entries();

                        for (G4int i=0; i<nDecays; i++)
                        {
                                const G4VDecayChannel* aDecay = theDecays->GetDecayChannel(i);
                                const G4int nDaughters = aDecay->GetNumberOfDaughters();

                                G4double minChannelMass = 0;

                                for (G4int j=0; j<nDaughters; j++)
                                {
                                        const G4ParticleDefinition* aDaughter = const_cast<G4VDecayChannel*>(aDecay)->GetDaughter(j);
                                        G4double minMass = GetMinimumMass(aDaughter);
                                        if (!minMass) minMass = DBL_MAX; // exclude gamma channel;
                                        minChannelMass+=minMass;
                                }
                                // G4cout << "channel mass for the above is " << minChannelMass/MeV << G4endl;
                                if (minChannelMass < minResonanceMass) minResonanceMass = minChannelMass;

                        }
                        // replace this as soon as the compiler supports mutable!!
                        G4SampleResonance* self = const_cast<G4SampleResonance*>(this);
                        (self->minMassCache)[p] = minResonanceMass;

                }
        } 
        else
        {

                minResonanceMass = p->GetPDGMass();

        }
        // G4cout << "minimal mass for " << p->GetParticleName() << " is " << minResonanceMass/MeV << G4endl;

        return minResonanceMass;
} 

G4double G4SampleResonance::SampleMass	(	const G4ParticleDefinition *	p,
		const G4double	maxMass
	)			const

Definition at line 102 of file G4SampleResonance.cc.

References GetMinimumMass(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetPDGWidth(), and SampleMass().

{
        return SampleMass(p->GetPDGMass(), p->GetPDGWidth(), GetMinimumMass(p), maxMass);
}

G4double G4SampleResonance::SampleMass	(	const G4double	poleMass,
		const G4double	gamma,
		const G4double	minMass,
		const G4double	maxMass
	)			const

Definition at line 108 of file G4SampleResonance.cc.

References DBL_EPSILON, and G4UniformRand.

Referenced by G4KineticTrack::Decay(), and SampleMass().

{
        // Chooses a mass randomly between minMass and maxMass
        //     according to a Breit-Wigner function with constant
        //     width gamma and pole poleMass

        if ( minMass > maxMass )
        {
                throw G4HadronicException(__FILE__, __LINE__,
                                "SampleResonanceMass: mass range negative (minMass>maxMass)");
        }

        G4double returnMass;

        if ( gamma < DBL_EPSILON )
        {
                returnMass = std::max(minMass, std::min(maxMass, poleMass));
        }
        else
        {
                double fmin = BrWigInt0(minMass, gamma, poleMass);
                double fmax = BrWigInt0(maxMass, gamma, poleMass);
                double f = fmin + (fmax-fmin)*G4UniformRand();
                returnMass = BrWigInv(f, gamma, poleMass);
        }

        return returnMass;
}

---

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

• G4SampleResonance.hh
• G4SampleResonance.cc

---