In This Package:

GenDecay::decay::BetaDecay

GenDecay::decay::BetaDecay Class Reference


Public Member Functions
def	__init__
def	__str__
def	energy
def	sampleEnergy
def	dnde
def	dnde_noff
def	fermi_function
Public Attributes
	qvalue
	kine
	doff
	onlyff
	parentZ
	daughterZ
	betaSign
	endpoint
	norm
	maximum
Private Member Functions
def	_normalize

Detailed Description

Nuclear decay by beta emission

Definition at line 24 of file decay.py.

Member Function Documentation

def GenDecay::decay::BetaDecay::__init__	(	self,
		qvalue,
		parentZ
	)

Definition at line 27 of file decay.py.

00027                                      :
00028         'Create a beta decay of the given qvalue and parentZ'
00029         self.qvalue = float(qvalue)
00030         self.kine = None
00031         self.doff = True        # for testing w/out fermi function
00032         self.onlyff = False     # for testing w/only fermi function
00033 
00034         if parentZ < 0:         # beta+ decay
00035             self.parentZ = -parentZ
00036             self.daughterZ = self.parentZ - 1
00037             self.betaSign = +1
00038             self.endpoint = self.qvalue - 2.0*units.electron_mass_c2
00039         else:                   # beta- decay
00040             self.parentZ = parentZ
00041             self.daughterZ = self.parentZ + 1
00042             self.betaSign = -1
00043             self.endpoint = self.qvalue
00044 
00045         self._normalize()
00046         return
    def _normalize(self):

def GenDecay::decay::BetaDecay::_normalize ( self ) [private]

Definition at line 47 of file decay.py.

00047                         :
00048         steps = 1000
00049         dx = self.endpoint/steps
00050         lo = dx/2.0
00051         self.norm = 1.0
00052         self.norm = sum([self.dnde(i*dx+lo)*dx for i in range(steps)])
00053         self.maximum = max([self.dnde(i*dx+lo) for i in range(steps)])
00054         #print 'norm=%f max=%f %s'%(self.norm,self.maximum,self)
00055         return
00056 
    def __str__(self):

def GenDecay::decay::BetaDecay::__str__ ( self )

Definition at line 57 of file decay.py.

00057                      :
00058         pm = '+'
00059         if self.betaSign < 0: pm = '-'
00060         return 'beta%s: Z=%d(->%d) Q=%.3f MeV'%(pm,self.parentZ,self.daughterZ,self.qvalue/units.MeV)
00061 
    def energy(self):

def GenDecay::decay::BetaDecay::energy ( self )

Definition at line 62 of file decay.py.

00062                     :
00063         if self.kine is None:
00064             self.kine = self.sampleEnergy()
00065         return self.kine
00066 
    def sampleEnergy(self):

def GenDecay::decay::BetaDecay::sampleEnergy ( self )

Definition at line 67 of file decay.py.

00067                           :
00068         from random import Random
00069         u = Random().uniform
00070         while True:
00071             T = u(0.0,self.endpoint)
00072             P = u(0.0,self.maximum)
00073             dnde = self.dnde(T)
00074             assert(type(T) is float)
00075             assert(type(P) is float)
00076             assert(type(dnde) is float)
00077             if P <= dnde: return T
00078             continue
00079         return None
00080 
    def dnde(self,T):

def GenDecay::decay::BetaDecay::dnde	(	self,
		T
	)

Definition at line 81 of file decay.py.

00081                     :
00082         if T > self.endpoint: return 0.0
00083         if T < 0.0: return 0.0
00084 
00085         if self.onlyff:
00086             ret = self.fermi_function(T)
00087         else:
00088             ret = self.dnde_noff(T)
00089             if self.doff: ret *= self.fermi_function(T)
00090         return ret/self.norm
00091 
    def dnde_noff(self,T):

def GenDecay::decay::BetaDecay::dnde_noff	(	self,
		T
	)

Return the unormalized dN/dE at the given beta kinetic
energy and ignoring nuclear Coulomb field

Definition at line 92 of file decay.py.

00092                          :
00093         '''Return the unormalized dN/dE at the given beta kinetic
00094         energy and ignoring nuclear Coulomb field'''
00095         import math
00096         W = self.endpoint/units.electron_mass_c2 + 1.0
00097         E = T/units.electron_mass_c2 + 1.0
00098         return math.sqrt(E**2-1.0) * (W-E)**2 * E
00099         
    def fermi_function(self,T):

def GenDecay::decay::BetaDecay::fermi_function	(	self,
		T
	)

Definition at line 100 of file decay.py.

00100                               :
00101         "Return the unormalized Fermi function value for given kinetic energy"
00102         import math
00103         E = T/units.electron_mass_c2 + 1.0
00104         P = math.sqrt(E*E-1.0)
00105         U = -1*self.betaSign*self.daughterZ/137.0
00106         S = math.sqrt(1.0 - U*U) - 1.0
00107         Y = 2.0*math.pi*U*E/P
00108         A1 = U*U * E*E + P*P/4.0
00109         A2 = math.fabs(Y/(1.0-math.exp(-Y)))
00110         return math.pow(A1,S)*A2
00111 
class GammaDecay(object):