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

Private Member Functions
G4double	BrWigInt0 (const G4double x, const G4double gamma, const G4double m0) const
G4double	BrWigInt1 (const G4double x, const G4double gamma, const G4double m0) const
G4double	BrWigInv (const G4double x, const G4double gamma, const G4double m0) const

Static Private Attributes
static G4ThreadLocal minMassMapType *	minMassCache_G4MT_TLS_ = 0

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

BrWigInt0()

G4double G4SampleResonance::BrWigInt0 ( const G4double  x, const G4double  gamma, const G4double  m0  ) const

inlineprivate

Definition at line 56 of file G4SampleResonance.hh.

    { return 2.0*gamma*std::atan( 2.0 * (x-m0)/ gamma  ); }

Referenced by BrWigInt1(), and SampleMass().

BrWigInt1()

G4double G4SampleResonance::BrWigInt1 ( const G4double  x, const G4double  gamma, const G4double  m0  ) const

inlineprivate

Definition at line 59 of file G4SampleResonance.hh.

    { return 0.5*gamma*gamma*G4Log( (x-m0)*(x-m0)+gamma*gamma/4.0 ) + m0*BrWigInt0(x,gamma,m0); }

References BrWigInt0(), and G4Log().

BrWigInv()

G4double G4SampleResonance::BrWigInv ( const G4double  x, const G4double  gamma, const G4double  m0  ) const

inlineprivate

Definition at line 62 of file G4SampleResonance.hh.

    { return 0.5*gamma*std::tan( 0.5*x/gamma )+m0; }

Referenced by SampleMass().

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;
} 

References DBL_MAX, G4DecayTable::entries(), G4VDecayChannel::GetBR(), G4DecayTable::GetDecayChannel(), G4ParticleDefinition::GetDecayTable(), GetMinimumMass(), G4VDecayChannel::GetNumberOfDaughters(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::IsShortLived(), G4INCL::Math::min(), and minMassCache_G4MT_TLS_.

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;
}

References BrWigInt0(), BrWigInv(), DBL_EPSILON, G4UniformRand, G4INCL::Math::max(), G4INCL::Math::min(), and minMassCache_G4MT_TLS_.

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);
}

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

Field Documentation

minMassCache_G4MT_TLS_

G4ThreadLocal G4SampleResonance::minMassMapType * G4SampleResonance::minMassCache_G4MT_TLS_ = 0

staticprivate

Definition at line 72 of file G4SampleResonance.hh.

Referenced by GetMinimumMass(), and SampleMass().

---

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

• source/processes/hadronic/util/include/G4SampleResonance.hh
• source/processes/hadronic/util/src/G4SampleResonance.cc