def __init__ ( self, rad_src ): self.PC = physical.PhysicalConstants() self.rad_src = rad_src # dont need to integrate for monochromatic spectra #----------------------------------------------------------------- if rad_src.monochromatic: self.Lu = rad_src.Lu self.Ln = self.Lu / rad_src.E # integrate for polychromatic spectra #----------------------------------------------------------------- else: self.Lu = utils.trap( rad_src.E, rad_src._dLu_over_dE ) self.Ln = utils.trap( rad_src.E, rad_src._dLn_over_dE ) # set units and docstrings #----------------------------------------------------------------- self.Lu.units = 'erg/s' self.Lu.__doc__ = 'optically thin energy luminosity' self.Ln.units = '1/s' self.Ln.__doc__ = 'optically thin photon luminosity'
def u(self,r): """ energy density at a given radius. """ if not hasattr(r,'units'): raise utils.NeedUnitsError, '\n r must have units \n' if self.rad_src.monochromatic: u = self.Fu(r) / self.PC.c else: u = utils.trap( self.rad_src.E, self.rad_src._du_over_dE(r) ) return u
def Fu(self,r): """ energy flux at a given radius. """ if not hasattr(r,'units'): raise utils.NeedUnitsError, '\n r must have units \n' if self.rad_src.monochromatic: Fu = self.Lu / (4.0 * np.pi * r*r) else: Fu = utils.trap( self.rad_src.E, self.rad_src._dFu_over_dE(r) ) return Fu
def n(self,r): """ photon density at a given radius. """ if not hasattr(r,'units'): raise utils.NeedUnitsError, '\n r must have units \n' if self.rad_src.monochromatic: n = self.Fn(r) / self.PC.c else: n = utils.trap( self.rad_src.E, self.rad_src._dn_over_dE(r) ) return n
def Fn(self,r): """ photon flux at a given radius. """ if not hasattr(r,'units'): raise utils.NeedUnitsError, '\n r must have units \n' if self.rad_src.monochromatic: Fn = self.Ln / (4.0 * np.pi * r*r) else: Fn = utils.trap( self.rad_src.E, self.rad_src._dFn_over_dE(r) ) return Fn
def He2i(self,r): """ He2 photoion rate at a given radius. """ if not hasattr(r,'units'): raise utils.NeedUnitsError, '\n r must have units \n' if self.rad_src.monochromatic: He2i = self.Fn(r) * self.rad_src.sigma.He2 else: He2i = utils.trap( self.rad_src.E, self.rad_src._dHe2i_over_dE(r) ) He2i.units = '1/s' return He2i
def He2h(self,r): """ He2 photoheating rate at a given radius. """ if not hasattr(r,'units'): raise utils.NeedUnitsError, '\n r must have units \n' if self.rad_src.monochromatic: He2h = self.He2i(r) * (self.rad_src.E - self.rad_src.th.E_He2) else: He2h = utils.trap( self.rad_src.E, self.rad_src._dHe2h_over_dE(r) ) He2h.units = 'erg/s' return He2h
def ta( self, a): r""" Time since a=0 or age of the Universe, t(a). .. math:: t(a) = \int_0^a \frac{da'}{a' H(a')} """ # quad works but takes a long time. #------------------------------------------------------------------- # if utils.isiterable( a ): # t = np.array( [quad( self._dt_da, 0.0, aa )[0] for aa in a] ) # else: # t = quad( self._dt_da, 0.0, a )[0] # t = t * self.cu.s # print 't = ', t.rescale("Myr/hh") # trap rule includes OmegaR and is fast and accurate to 6 decimals #------------------------------------------------------------------- N = 5000 a_min = 1.0e-10 if utils.isiterable( a ): t = np.zeros( a.size ) * self.cu.s for ii,aa in enumerate(a): xx = np.linspace( a_min, aa, N ) yy = 1.0 / ( xx * self.Ha(xx) ) t[ii] = utils.trap( xx, yy ) else: xx = np.linspace( a_min, a, N ) yy = 1.0 / ( xx * self.Ha(xx) ) t = utils.trap( xx, yy ) t.units = 'Myr/hh' # this is analytic but does not include OmegaR #------------------------------------------------------------------- # pre = 2.0 / ( 3.0 * np.sqrt( self.OmegaL ) ) # aeq = (self.OmegaM/self.OmegaL)**(1./3.) # arg = (a/aeq)**(3./2.) + np.sqrt(1 + (a/aeq)**3) # t = pre * np.log(arg) * self.tH0 return t
def ta(self, a): r""" Time since a=0 or age of the Universe, t(a). .. math:: t(a) = \int_0^a \frac{da'}{a' H(a')} """ # quad works but takes a long time. #------------------------------------------------------------------- # if utils.isiterable( a ): # t = np.array( [quad( self._dt_da, 0.0, aa )[0] for aa in a] ) # else: # t = quad( self._dt_da, 0.0, a )[0] # t = t * self.cu.s # print 't = ', t.rescale("Myr/hh") # trap rule includes OmegaR and is fast and accurate to 6 decimals #------------------------------------------------------------------- N = 5000 a_min = 1.0e-10 if utils.isiterable(a): t = np.zeros(a.size) * self.cu.s for ii, aa in enumerate(a): xx = np.linspace(a_min, aa, N) yy = 1.0 / (xx * self.Ha(xx)) t[ii] = utils.trap(xx, yy) else: xx = np.linspace(a_min, a, N) yy = 1.0 / (xx * self.Ha(xx)) t = utils.trap(xx, yy) t.units = 'Myr/hh' # this is analytic but does not include OmegaR #------------------------------------------------------------------- # pre = 2.0 / ( 3.0 * np.sqrt( self.OmegaL ) ) # aeq = (self.OmegaM/self.OmegaL)**(1./3.) # arg = (a/aeq)**(3./2.) + np.sqrt(1 + (a/aeq)**3) # t = pre * np.log(arg) * self.tH0 return t
def shld_He2h(self, tauH1_th, tauHe1_th, tauHe2_th): """ Integrates spectrum to calculate the HeII photoheating rate after passing through a column with optical depth tau. .. seealso:: :func:`shld_H1h` """ atten = self.return_attenuation( tauH1_th, tauHe1_th, tauHe2_th ) if self.monochromatic: He2h = self.thin.He2h * atten else: He2h = utils.trap( self.E, self._dHe2h_over_dE * atten ) He2h.units = 'erg/s' return He2h
def shld_He2h(self, tauH1_th, tauHe1_th, tauHe2_th): """ Integrates spectrum to calculate the HeII photoheating rate after passing through a column with optical depth tau. .. seealso:: :func:`shld_H1h` """ atten = self.return_attenuation(tauH1_th, tauHe1_th, tauHe2_th) if self.monochromatic: He2h = self.thin.He2h * atten else: He2h = utils.trap(self.E, self._dHe2h_over_dE * atten) He2h.units = 'erg/s' return He2h
def shld_He2i(self, r, tauH1_th, tauHe1_th, tauHe2_th): """ Integrates spectrum to calculate the HeII photoionization rate after passing through a column with optical depth tau. .. seealso:: :func:`shld_H1i` """ atten = self.return_attenuation( tauH1_th, tauHe1_th, tauHe2_th ) if self.monochromatic: He2i = self.thin.He2i(r) * atten else: He2i = utils.trap( self.E, self._dHe2i_over_dE(r) * atten ) He2i.units = '1/s' return He2i
def shld_H1h(self, tauH1_th, tauHe1_th, tauHe2_th): """ Integrates spectrum to calculate the HI photoheating rate after passing through a column with optical depth tau Args: `tauH1_th` (float): H1 optical depth at the H1 ionizing threshold `tauHe1_th` (float): He1 optical depth at the He1 ionizing threshold `tauHe2_th` (float): He2 optical depth at the He2 ionizing threshold Returns: `H1h` (float): attenuated H1 photoheating rate """ atten = self.return_attenuation( tauH1_th, tauHe1_th, tauHe2_th ) if self.monochromatic: H1h = self.thin.H1h * atten else: H1h = utils.trap( self.E, self._dH1h_over_dE * atten ) H1h.units = 'erg/s' return H1h
def shld_H1h(self, tauH1_th, tauHe1_th, tauHe2_th): """ Integrates spectrum to calculate the HI photoheating rate after passing through a column with optical depth tau Args: `tauH1_th` (float): H1 optical depth at the H1 ionizing threshold `tauHe1_th` (float): He1 optical depth at the He1 ionizing threshold `tauHe2_th` (float): He2 optical depth at the He2 ionizing threshold Returns: `H1h` (float): attenuated H1 photoheating rate """ atten = self.return_attenuation(tauH1_th, tauHe1_th, tauHe2_th) if self.monochromatic: H1h = self.thin.H1h * atten else: H1h = utils.trap(self.E, self._dH1h_over_dE * atten) H1h.units = 'erg/s' return H1h
def shld_H1i(self, r, tauH1_th, tauHe1_th, tauHe2_th): """ Integrates spectrum to calculate the HI photoionization rate after passing through a column with optical depth tau Args: `r` (float): radial distance from point source `tauH1_th` (float): H1 optical depth at the H1 ionizing threshold `tauHe1_th` (float): He1 optical depth at the He1 ionizing threshold `tauHe2_th` (float): He2 optical depth at the He2 ionizing threshold Returns: `H1i` (float): attenuated H1 photoionization rate """ atten = self.return_attenuation( tauH1_th, tauHe1_th, tauHe2_th ) if self.monochromatic: H1i = self.thin.H1i(r) * atten else: H1i = utils.trap( self.E, self._dH1i_over_dE(r) * atten ) H1i.units = '1/s' return H1i
def __init__ ( self, rad_src ): self.PC = physical.PhysicalConstants() self.U = units.Units() # dont need to integrate for monochromatic spectra #----------------------------------------------------------------- if rad_src.monochromatic: four_pi_sr = 4 * np.pi * self.U.sr self.Fu = four_pi_sr * rad_src.Inu self.u = self.Fu / self.PC.c self.Fn = self.Fu / rad_src.E self.n = self.Fn / self.PC.c self.H1i = self.Fn * rad_src.sigma.H1 self.H1h = self.H1i * (rad_src.E - rad_src.th.E_H1) self.He1i = self.Fn * rad_src.sigma.He1 self.He1h = self.He1i * (rad_src.E - rad_src.th.E_He1) self.He2i = self.Fn * rad_src.sigma.He2 self.He2h = self.He2i * (rad_src.E - rad_src.th.E_He2) # integrate for polychromatic spectra #----------------------------------------------------------------- else: self.Fu = utils.trap( rad_src.E, rad_src._dFu_over_dE ) self.u = utils.trap( rad_src.E, rad_src._du_over_dE ) self.Fn = utils.trap( rad_src.E, rad_src._dFn_over_dE ) self.n = utils.trap( rad_src.E, rad_src._dn_over_dE ) self.H1i = utils.trap( rad_src.E, rad_src._dH1i_over_dE ) self.H1h = utils.trap( rad_src.E, rad_src._dH1h_over_dE ) self.He1i = utils.trap(rad_src.E, rad_src._dHe1i_over_dE) self.He1h = utils.trap(rad_src.E, rad_src._dHe1h_over_dE) self.He2i = utils.trap(rad_src.E, rad_src._dHe2i_over_dE) self.He2h = utils.trap(rad_src.E, rad_src._dHe2h_over_dE) # set units and docstrings #----------------------------------------------------------------- self.Fu.units = 'erg/s/cm^2' self.Fu.__doc__ = 'optically thin energy flux' self.u.units = 'erg/cm^3' self.u.__doc__ = 'optically thin energy density' self.Fn.units = '1/s/cm^2' self.Fn.__doc__ = 'optically thin photon number flux' self.n.units = '1/cm^3' self.n.__doc__ = 'optically thin photon number density' self.H1i.units = '1/s' self.H1i.__doc__ = 'optically thin H1 photoionization rate' self.H1h.units = 'erg/s' self.H1h.__doc__ = 'optically thin H1 photoheating rate' self.He1i.units = '1/s' self.He1i.__doc__ = 'optically thin He1 photoionization rate' self.He1h.units = 'erg/s' self.He1h.__doc__ = 'optically thin He1 photoheating rate' self.He2i.units = '1/s' self.He2i.__doc__ = 'optically thin He2 photoionization rate' self.He2h.units = 'erg/s' self.He2h.__doc__ = 'optically thin He2 photoheating rate'
def __init__( self, rad_src ): # make sure we have what we need #-------------------------------------------- assert rad_src.segmented == True # setup containers #-------------------------------------------- self.sigma = species.AbsorbingSpecies() self.E = species.AbsorbingSpecies() # integrate between H1 and He1 thresholds #-------------------------------------------- ii = rad_src.th.i_H1 ff = rad_src.th.i_He1 xx = rad_src.E[ii:ff] yy = rad_src._dH1i_over_dE[ii:ff] H1i_thin = utils.trap( xx, yy ) yy = rad_src._dFn_over_dE[ii:ff] Fn_thin = utils.trap( xx, yy ) self.sigma.H1 = H1i_thin / Fn_thin self.sigma.H1.__doc__ = 'grey H1 photoionization cross section' log_sig = np.log10( rad_src.sigma.H1[ii:ff].magnitude ) log_gry = np.log10( self.sigma.H1.magnitude ) log_E = np.log10( rad_src.E[ii:ff].magnitude ) i_lo = np.argmin( np.abs( log_sig - log_gry ) ) if log_sig[i_lo] < log_gry: i_hi = i_lo + 1 else: i_hi = i_lo i_lo = i_lo - 1 dlogsig = log_sig[i_hi] - log_sig[i_lo] frac = (log_gry - log_sig[i_lo]) / dlogsig dlogE = log_E[i_hi] - log_E[i_lo] grey_E = 10.0**(log_E[i_lo] + frac * dlogE) self.E.H1 = grey_E * rad_src.U.eV self.E.H1.__doc__ = 'grey H1 energy' # integrate between He1 and He2 thresholds #-------------------------------------------- ii = rad_src.th.i_He1 ff = rad_src.th.i_He2 xx = rad_src.E[ii:ff] yy = rad_src._dHe1i_over_dE[ii:ff] He1i_thin = utils.trap( xx, yy ) yy = rad_src._dFn_over_dE[ii:ff] Fn_thin = utils.trap( xx, yy ) self.sigma.He1 = He1i_thin / Fn_thin self.sigma.He1.__doc__ = 'grey He1 photoionization cross section' log_sig = np.log10( rad_src.sigma.He1[ii:ff].magnitude ) log_gry = np.log10( self.sigma.He1.magnitude ) log_E = np.log10( rad_src.E[ii:ff].magnitude ) i_lo = np.argmin( np.abs( log_sig - log_gry ) ) if log_sig[i_lo] < log_gry: i_hi = i_lo + 1 else: i_hi = i_lo i_lo = i_lo - 1 dlogsig = log_sig[i_hi] - log_sig[i_lo] frac = (log_gry - log_sig[i_lo]) / dlogsig dlogE = log_E[i_hi] - log_E[i_lo] grey_E = 10.0**(log_E[i_lo] + frac * dlogE) self.E.He1 = grey_E * rad_src.U.eV self.E.He1.__doc__ = 'grey He1 energy' # integrate above He2 threshold #-------------------------------------------- ii = rad_src.th.i_He2 xx = rad_src.E[ii:] yy = rad_src._dHe2i_over_dE[ii:] He2i_thin = utils.trap( xx, yy ) yy = rad_src._dFn_over_dE[ii:] Fn_thin = utils.trap( xx, yy ) self.sigma.He2 = He2i_thin / Fn_thin self.sigma.He2.__doc__ = 'grey He2 photoionization cross section' log_sig = np.log10( rad_src.sigma.He2[ii:].magnitude ) log_gry = np.log10( self.sigma.He2.magnitude ) log_E = np.log10( rad_src.E[ii:].magnitude ) i_lo = np.argmin( np.abs( log_sig - log_gry ) ) if log_sig[i_lo] < log_gry: i_hi = i_lo + 1 else: i_hi = i_lo i_lo = i_lo - 1 dlogsig = log_sig[i_hi] - log_sig[i_lo] frac = (log_gry - log_sig[i_lo]) / dlogsig dlogE = log_E[i_hi] - log_E[i_lo] grey_E = 10.0**(log_E[i_lo] + frac * dlogE) self.E.He2 = grey_E * rad_src.U.eV self.E.He2.__doc__ = 'grey He2 energy'
def __init__(self, rad_src): self.PC = physical.PhysicalConstants() # dont need to integrate for monochromatic spectra #----------------------------------------------------------------- if rad_src.monochromatic: self.Fu = rad_src.Fu self.u = self.Fu / self.PC.c self.Fn = self.Fu / rad_src.E self.n = self.Fn / self.PC.c self.H1i = self.Fn * rad_src.sigma.H1 self.H1h = self.H1i * (rad_src.E - rad_src.th.E_H1) self.He1i = self.Fn * rad_src.sigma.He1 self.He1h = self.He1i * (rad_src.E - rad_src.th.E_He1) self.He2i = self.Fn * rad_src.sigma.He2 self.He2h = self.He2i * (rad_src.E - rad_src.th.E_He2) # integrate for polychromatic spectra #----------------------------------------------------------------- else: self.Fu = utils.trap(rad_src.E, rad_src._dFu_over_dE) self.u = utils.trap(rad_src.E, rad_src._du_over_dE) self.Fn = utils.trap(rad_src.E, rad_src._dFn_over_dE) self.n = utils.trap(rad_src.E, rad_src._dn_over_dE) self.H1i = utils.trap(rad_src.E, rad_src._dH1i_over_dE) self.H1h = utils.trap(rad_src.E, rad_src._dH1h_over_dE) self.He1i = utils.trap(rad_src.E, rad_src._dHe1i_over_dE) self.He1h = utils.trap(rad_src.E, rad_src._dHe1h_over_dE) self.He2i = utils.trap(rad_src.E, rad_src._dHe2i_over_dE) self.He2h = utils.trap(rad_src.E, rad_src._dHe2h_over_dE) # set units and docstrings #----------------------------------------------------------------- self.Fu.units = 'erg/s/cm^2' self.Fu.__doc__ = 'optically thin energy flux' self.u.units = 'erg/cm^3' self.u.__doc__ = 'optically thin energy density' self.Fn.units = '1/s/cm^2' self.Fn.__doc__ = 'optically thin photon number flux' self.n.units = '1/cm^3' self.n.__doc__ = 'optically thin photon number density' self.H1i.units = '1/s' self.H1i.__doc__ = 'optically thin H1 photoionization rate' self.H1h.units = 'erg/s' self.H1h.__doc__ = 'optically thin H1 photoheating rate' self.He1i.units = '1/s' self.He1i.__doc__ = 'optically thin He1 photoionization rate' self.He1h.units = 'erg/s' self.He1h.__doc__ = 'optically thin He1 photoheating rate' self.He2i.units = '1/s' self.He2i.__doc__ = 'optically thin He2 photoionization rate' self.He2h.units = 'erg/s' self.He2h.__doc__ = 'optically thin He2 photoheating rate'
def __init__(self, rad_src): # make sure we have what we need #-------------------------------------------- assert rad_src.segmented == True # setup containers #-------------------------------------------- self.sigma = species.AbsorbingSpecies() self.E = species.AbsorbingSpecies() # integrate between H1 and He1 thresholds #-------------------------------------------- ii = rad_src.th.i_H1 ff = rad_src.th.i_He1 xx = rad_src.E[ii:ff] yy = rad_src._dH1i_over_dE[ii:ff] H1i_thin = utils.trap(xx, yy) yy = rad_src._dFn_over_dE[ii:ff] Fn_thin = utils.trap(xx, yy) self.sigma.H1 = H1i_thin / Fn_thin self.sigma.H1.__doc__ = 'grey H1 photoionization cross section' log_sig = np.log10(rad_src.sigma.H1[ii:ff].magnitude) log_gry = np.log10(self.sigma.H1.magnitude) log_E = np.log10(rad_src.E[ii:ff].magnitude) i_lo = np.argmin(np.abs(log_sig - log_gry)) if log_sig[i_lo] < log_gry: i_hi = i_lo + 1 else: i_hi = i_lo i_lo = i_lo - 1 dlogsig = log_sig[i_hi] - log_sig[i_lo] frac = (log_gry - log_sig[i_lo]) / dlogsig dlogE = log_E[i_hi] - log_E[i_lo] grey_E = 10.0**(log_E[i_lo] + frac * dlogE) self.E.H1 = grey_E * rad_src.U.eV self.E.H1.__doc__ = 'grey H1 energy' # integrate between He1 and He2 thresholds #-------------------------------------------- ii = rad_src.th.i_He1 ff = rad_src.th.i_He2 xx = rad_src.E[ii:ff] yy = rad_src._dHe1i_over_dE[ii:ff] He1i_thin = utils.trap(xx, yy) yy = rad_src._dFn_over_dE[ii:ff] Fn_thin = utils.trap(xx, yy) self.sigma.He1 = He1i_thin / Fn_thin self.sigma.He1.__doc__ = 'grey He1 photoionization cross section' log_sig = np.log10(rad_src.sigma.He1[ii:ff].magnitude) log_gry = np.log10(self.sigma.He1.magnitude) log_E = np.log10(rad_src.E[ii:ff].magnitude) i_lo = np.argmin(np.abs(log_sig - log_gry)) if log_sig[i_lo] < log_gry: i_hi = i_lo + 1 else: i_hi = i_lo i_lo = i_lo - 1 dlogsig = log_sig[i_hi] - log_sig[i_lo] frac = (log_gry - log_sig[i_lo]) / dlogsig dlogE = log_E[i_hi] - log_E[i_lo] grey_E = 10.0**(log_E[i_lo] + frac * dlogE) self.E.He1 = grey_E * rad_src.U.eV self.E.He1.__doc__ = 'grey He1 energy' # integrate above He2 threshold #-------------------------------------------- ii = rad_src.th.i_He2 xx = rad_src.E[ii:] yy = rad_src._dHe2i_over_dE[ii:] He2i_thin = utils.trap(xx, yy) yy = rad_src._dFn_over_dE[ii:] Fn_thin = utils.trap(xx, yy) self.sigma.He2 = He2i_thin / Fn_thin self.sigma.He2.__doc__ = 'grey He2 photoionization cross section' log_sig = np.log10(rad_src.sigma.He2[ii:].magnitude) log_gry = np.log10(self.sigma.He2.magnitude) log_E = np.log10(rad_src.E[ii:].magnitude) i_lo = np.argmin(np.abs(log_sig - log_gry)) if log_sig[i_lo] < log_gry: i_hi = i_lo + 1 else: i_hi = i_lo i_lo = i_lo - 1 dlogsig = log_sig[i_hi] - log_sig[i_lo] frac = (log_gry - log_sig[i_lo]) / dlogsig dlogE = log_E[i_hi] - log_E[i_lo] grey_E = 10.0**(log_E[i_lo] + frac * dlogE) self.E.He2 = grey_E * rad_src.U.eV self.E.He2.__doc__ = 'grey He2 energy'
def calc_weighted( self, wa ): """ Calculates all integrals weighted by wa. """ wq = Averaged() xx = self.z_c # <xH1>_w #------------------------------------------------ yy = wa * self.xH1 num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.xH1 = num / den # <xH2>_w #------------------------------------------------ yy = wa * self.xH2 num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.xH2 = num / den # <xHe1>_w #------------------------------------------------ yy = wa * self.xHe1 num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.xHe1 = num / den # <xHe2>_w #------------------------------------------------ yy = wa * self.xHe2 num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.xHe2 = num / den # <xHe3>_w #------------------------------------------------ yy = wa * self.xHe3 num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.xHe3 = num / den # <T>_w #------------------------------------------------ yy = wa * self.T num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.T = num / den # <mu>_w #------------------------------------------------ yy = wa * self.mu num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.mu = num / den # <H1i>_w #------------------------------------------------ yy = wa * self.H1i num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.H1i = num / den yy = wa * self.H1i_src num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.H1i_src = num / den yy = wa * self.H1i_rec num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.H1i_rec = num / den # <He1i>_w #------------------------------------------------ yy = wa * self.He1i num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He1i = num / den yy = wa * self.He1i_src num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He1i_src = num / den yy = wa * self.He1i_rec num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He1i_rec = num / den # <He2i>_w #------------------------------------------------ yy = wa * self.He2i num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He2i = num / den yy = wa * self.He2i_src num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He2i_src = num / den yy = wa * self.He2i_rec num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He2i_rec = num / den # <H1h>_w #------------------------------------------------ yy = wa * self.H1h num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.H1h = num / den yy = wa * self.H1h_src num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.H1h_src = num / den yy = wa * self.H1h_rec num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.H1h_rec = num / den # <He1h>_w #------------------------------------------------ yy = wa * self.He1h num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He1h = num / den yy = wa * self.He1h_src num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He1h_src = num / den yy = wa * self.He1h_rec num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He1h_rec = num / den # <He2h>_w #------------------------------------------------ yy = wa * self.He2h num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He2h = num / den yy = wa * self.He2h_src num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He2h_src = num / den yy = wa * self.He2h_rec num = utils.trap( xx, yy ) den = utils.trap( xx, wa ) wq.He2h_rec = num / den return wq
def calc_weighted(self, wa): """ Calculates all integrals weighted by wa. """ wq = Averaged() xx = self.z_c # <xH1>_w #------------------------------------------------ yy = wa * self.xH1 num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.xH1 = num / den # <xH2>_w #------------------------------------------------ yy = wa * self.xH2 num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.xH2 = num / den # <xHe1>_w #------------------------------------------------ yy = wa * self.xHe1 num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.xHe1 = num / den # <xHe2>_w #------------------------------------------------ yy = wa * self.xHe2 num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.xHe2 = num / den # <xHe3>_w #------------------------------------------------ yy = wa * self.xHe3 num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.xHe3 = num / den # <T>_w #------------------------------------------------ yy = wa * self.T num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.T = num / den # <mu>_w #------------------------------------------------ yy = wa * self.mu num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.mu = num / den # <H1i>_w #------------------------------------------------ yy = wa * self.H1i num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.H1i = num / den yy = wa * self.H1i_src num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.H1i_src = num / den yy = wa * self.H1i_rec num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.H1i_rec = num / den # <He1i>_w #------------------------------------------------ yy = wa * self.He1i num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He1i = num / den yy = wa * self.He1i_src num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He1i_src = num / den yy = wa * self.He1i_rec num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He1i_rec = num / den # <He2i>_w #------------------------------------------------ yy = wa * self.He2i num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He2i = num / den yy = wa * self.He2i_src num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He2i_src = num / den yy = wa * self.He2i_rec num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He2i_rec = num / den # <H1h>_w #------------------------------------------------ yy = wa * self.H1h num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.H1h = num / den yy = wa * self.H1h_src num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.H1h_src = num / den yy = wa * self.H1h_rec num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.H1h_rec = num / den # <He1h>_w #------------------------------------------------ yy = wa * self.He1h num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He1h = num / den yy = wa * self.He1h_src num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He1h_src = num / den yy = wa * self.He1h_rec num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He1h_rec = num / den # <He2h>_w #------------------------------------------------ yy = wa * self.He2h num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He2h = num / den yy = wa * self.He2h_src num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He2h_src = num / den yy = wa * self.He2h_rec num = utils.trap(xx, yy) den = utils.trap(xx, wa) wq.He2h_rec = num / den return wq