G4SampleResonance Class Reference

#include <G4SampleResonance.hh>

Public Types
typedef std::map< constG4ParticleDefinition *, G4double, std::less< constG4ParticleDefinition * > >::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 43 of file G4SampleResonance.hh.

Member Typedef Documentation

minMassMapIterator

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

Definition at line 67 of file G4SampleResonance.hh.

minMassMapType

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

Definition at line 68 of file G4SampleResonance.hh.

Member Function Documentation

GetMinimumMass()

G4double G4SampleResonance::GetMinimumMass

(

const G4ParticleDefinition *

p

)

const

Definition at line 46 of file G4SampleResonance.cc.

{  ;;;   if (!minMassCache_G4MT_TLS_) minMassCache_G4MT_TLS_ = new G4SampleResonance::minMassMapType  ; G4SampleResonance::minMassMapType &minMassCache = *minMassCache_G4MT_TLS_;  ;;;  
 
    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 = p->GetDecayTable();
            const G4int nDecays = theDecays->entries();
 
            // To find the minimum mass of the resonance, consider only the
            // decay channels whose branching ratio is above a given threshold.
            // This is needed to avoid that rare and light decay channels
            // (e.g. e+ e-) can set a very small minimum mass of the resonance.
            // In the case that no channel with branching ratio above the
            // threshold has been found, consider the channel with the highest
            // branching ratio (whatever its values).
            // Note that this solution works also when rare decays are artificially
                    // enhanced if both of the following conditions hold:
                        // 1. The enhanced rare decays have branching ratios below the threshold
                        // 2. The decay with the highest branching ratio is a "natural" decay,
            //    i.e. not a rare decay which has been artificially enhanced.
            const G4double thresholdChannelProbability = 0.10;
            G4double foundChannelAboveThresholdProbability = false;
            G4double minMassMostProbableChannel = 0.0;
            G4double highestChannelProbability = 0.0;
            for (G4int i=0; i<nDecays; i++)
            {
                const G4VDecayChannel* aDecay = theDecays->GetDecayChannel(i);
                G4double decayBr = aDecay->GetBR();
                if (decayBr > std::min(highestChannelProbability, thresholdChannelProbability))
                {
                  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;
                  }
                  if (decayBr > highestChannelProbability)
                  {
                    highestChannelProbability = decayBr;
                    minMassMostProbableChannel = minChannelMass;
                  }
                  if (decayBr > thresholdChannelProbability)
                  {
                    foundChannelAboveThresholdProbability = true;
                    if (minChannelMass < minResonanceMass) minResonanceMass = minChannelMass;
                  }
                                }
            }
            if ( ! foundChannelAboveThresholdProbability ) {
              minResonanceMass = minMassMostProbableChannel;
            }
            // replace this as soon as the compiler supports mutable!!
            G4SampleResonance* self = const_cast<G4SampleResonance*>(this);
            //Andrea Dotti (13Jan2013): Change needed for G4MT
            //(self->minMassCache)[p] = minResonanceMass;
            self->minMassCache_G4MT_TLS_->operator[](p) = minResonanceMass;
 
        }
    } 
    else
    {
 
        minResonanceMass = p->GetPDGMass();
 
    }
    // G4cout << "minimal mass for " << p->GetParticleName() << " is " << minResonanceMass/MeV << G4endl;
 
    return minResonanceMass;
} 

Referenced by G4KineticTrack::Decay(), G4ExcitedStringDecay::FragmentStrings(), G4KineticTrack::G4KineticTrack(), GetMinimumMass(), and SampleMass().

SampleMass() [1/2]

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

Definition at line 138 of file G4SampleResonance.cc.

{ if (!minMassCache_G4MT_TLS_) minMassCache_G4MT_TLS_ = new G4SampleResonance::minMassMapType  ;
    // Chooses a mass randomly between minMass and maxMass
    //     according to a Breit-Wigner function with constant
    //     width gamma and pole poleMass
 
 
        //AR-14Nov2017 : protection for rare cases when a wide parent resonance, with a very small
        //               dynamic mass, decays into another wide (daughter) resonance: it can happen
        //               then that for the daugther resonance minMass > maxMass : in these cases,
        //               do not crash, but simply consider maxMass as the minimal mass for
        //               the sampling of the daughter resonance mass.
        G4double protectedMinMass = minMass;
    if ( minMass > maxMass )
    {
        //throw G4HadronicException(__FILE__, __LINE__,
        //        "SampleResonanceMass: mass range negative (minMass>maxMass)");
                protectedMinMass = maxMass;
    }
 
    G4double returnMass;
 
    if ( gamma < DBL_EPSILON )
    {
        returnMass = std::max(minMass, std::min(maxMass, poleMass));
    }
    else
    {
        //double fmin = BrWigInt0(minMass, gamma, poleMass);
        double fmin = BrWigInt0(protectedMinMass, gamma, poleMass);
        double fmax = BrWigInt0(maxMass, gamma, poleMass);
        double f = fmin + (fmax-fmin)*G4UniformRand();
        returnMass = BrWigInv(f, gamma, poleMass);
    }
 
    return returnMass;
}

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

SampleMass() [2/2]

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

Definition at line 132 of file G4SampleResonance.cc.

{ if (!minMassCache_G4MT_TLS_) minMassCache_G4MT_TLS_ = new G4SampleResonance::minMassMapType  ;
    return SampleMass(p->GetPDGMass(), p->GetPDGWidth(), GetMinimumMass(p), maxMass);
}

---

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

• G4SampleResonance.hh
• G4SampleResonance.cc