Public Member Functions
def	__init__
	Cloudy model object.
def	read_outputs
def	zones
	array of zones [int array]
def	n_zones
	number of zones [int]
def	depth
	depth [float array] (cm)
def	thickness
	thickness [float array] (cm)
def	radius
	radius [float array] (cm)
def	dr
	size of each zone [float array] (cm)
def	drff
	size of each zone taking into account filling factor [float array] (cm)
def	dv
	volume of each zone [float array] (cm^3)
def	dvff
	volume of each zone taking into account filling factor [float array] (cm^3)
def	ne
	electron density [float array] (cm^-3)
def	nH
	Hydrogen density [float array] (cm^-3)
def	nenH
	ne.nH [float array] (cm^-6)
def	te
	Electron temperature [float array] (K)
def	tenenH
	te.ne.nH [float array] (K.cm^-6)
def	ff
	filling factor [float array]
def	cool
	cooling [float array]
def	heat
	heating [float array]
def	log_U
	log(U) in each zone [float array], with U(r) = $Q_0 / (4.\pi.r^2.n_H.c)$
def	log_U_mean
	log_U_mean = $\frac{\int U.dV}{\int dV}$ [float]
def	log_U_mean_ne
	log_U_mean_ne = $\frac{\int U.ne.dV}{\int ne.dV}$ [float]
def	get_ionic
def	gtemp
def	gabund
def	gdgrat
def	get_T0_ion_vol
	get_T0_ion_vol(X, i) = $\frac{\int T_e.n_H.ff.X^i/X.dV}{\int n_H.ff.X^i/X.dV}$
def	get_T0_ion_rad
	get_T0_ion_rad(X, i) = $\frac{\int T_e.n_H.ff.X^i/X.dr}{\int n_H.ff.X^i/X.dr}$
def	get_ab_ion_vol
	get_ab_ion_vol(X, i) = $\frac{\int X^i/X.n_H.ff.dr}{\int n_H.ff.dr}$
def	get_ab_ion_rad
	get_ab_ion_rad(X, i) = $\frac{\int X^i/X.n_H.ff.dr}{\int n_H.ff.dr}$
def	get_ne_ion_vol_ne
	get_ne_ion_vol_ne(X, i) = $\frac{\int ne.ne.nH.ff.Xi/X.dV}{\int ne.nH.ff.Xi/X.dV}$
def	get_T0_ion_vol_ne
	get_T0_ion_vol_ne(X, i) = $\frac{\int Te.ne.nH.ff.Xi/X.dV}{\int ne.nH.ff.X^i/X.dV}$
def	get_T0_ion_rad_ne
	get_T0_ion_rad_ne(X, i) = $\frac{\int Te.ne.nH.ff.Xi/X.dr}{\int ne.nH.ff.Xi/X.dr}$
def	get_ne_ion_rad_ne
	get_ne_ion_rad_ne(X, i) = $\frac{\int ne.ne.nH.ff.Xi/X.dr}{\int ne.nH.ff.Xi/X.dr}$
def	get_ab_ion_vol_ne
	get_ab_ion_vol_ne(X, i) = $\frac{\int Xi/X.n_e.n_H.ff.dV}{\int ne.nH.ff.dV}$
def	get_ab_ion_rad_ne
	get_ab_ion_rad_ne(X, i) = $\frac{\int Xi/X.n_e.n_H.ff.dr}{\int ne.nH.ff.dr}$
def	get_t2_ion_vol_ne
	get_t2_ion_vol_ne(X, i) = $\frac{\int (T_e-T_{X^i})^2.n_e.n_H.ff.X^i/X.dV}{T_{X^i}^2.\int ne.nH.ff.X^i/X.dV}$
def	get_t2_ion_rad_ne
	get_t2_ion_vol_ne(X, i) = $\frac{\int (T_e-T_{X^i})^2.n_e.n_H.ff.X^i/X.dr}{T_{X^i}^2.\int ne.nH.ff.X^i/X.dr}$
def	get_line
def	get_emis
	return the emissivities(radius) of the given line [array float] (erg/cm^3/s)
def	get_emis_vol
	get_emis_vol(ref, [at_earth]) = $\int \epsilon(ref).dV [/ 4.\pi.(distance)^2]$
def	get_emis_rad
	get_emis_rad(ref) = $\int \epsilon(ref).dr$
def	get_T0_emis
	get_T0_emis(ref) = $\frac{\int T_e.\epsilon(ref).dV}{\int \epsilon(ref).dV}$
def	get_T0_emis_rad
	get_T0_emis_rad(ref) = $\frac{\int T_e.\epsilon(ref).dr}{\int \epsilon(ref).dr}$
def	get_ne_emis
	get_ne_emis(ref) = $\frac{\int n_e.\epsilon(ref).dV}{\int \epsilon(ref).dV}$
def	nH_mean
def	get_t2_emis
	get_t2_emis(ref) = $\frac{\int (T_e-T(ref))^2.\epsilon(ref).dV}{T(ref)^2\int \epsilon(ref).dV}$
def	get_cont_x
	Return the wavelength/energy/frequency array.
def	get_cont_y
def	get_G0
	get_G0 = integral(f_lambda .
def	rad_integ
	rad_integ(a) = $\int a.ff.dr$
def	vol_integ
	vol_integ(a) = $\int a.ff.dV$
def	vol_mean
	vol_mean(a, b) = $\frac{\int a.b.ff.dV}{\int b.ff.dV}$
def	rad_mean
	rad_mean(a, b) = $\frac{\int a.b.dr}{\int b.dr}$
def	r_range
	Boolean array defining the range used for the radial parameters (such as ne, ionic, integrals, etc) Defined by r_in_cut and r_out_cut.
def	Hp_mass
	Hp_mass = $\int m_H.n_{H^+}.ff.dV$ [solar mass].
def	H0_mass
	H0_mass = $\int m_H.n_{H^0}.ff.dV$ [solar mass].
def	H_mass
	H0_mass = $\int m_H.n_H.ff.dV$ [solar mass].
def	T0
	Mean Temperature $T0=\frac{\int T_e.n_e.n_H.ff.dV}{\int n_e.n_H.ff.dV}$ .
def	t2
	t2 a la Peimbert $t^2=\frac{\int (T_e-T0)^2.n_e.n_H.ff.dV}{T0^2 \int n_e.n_H.ff.dV}$
def	get_Hb_SB
	Hb_SB = I$_ / (Rout^2 * pi * 206265.
def	is_valid_ion
	is_valid_ion(elem, ion) return True if elem, ion is available in get_ionic.
def	emis_from_pyneb
def	print_lines
def	print_stats
def	__repr__
def	__str__
Public Attributes
	log_
	logging tool [my_logging object]
	calling
	model_name
	name of the model [str]
	model_name_s
	line_is_log
	emis_is_log
	distance
	distance to the object (kpc)
	liste_elem
	n_ions
	ionic_full
	ionic_names
	n_zones_full
	total number of zones, r_range unused [int]
	zones_full
	arrays of zones, r_range unused [int array]
	depth_full
	array of depths, r_range unused [float array] (cm)
	radius_full
	array of radius, r_range unused [float array] (cm)
	dv_full
	array of volume element of each zone, r_range unused [float array] ( )
	dr_full
	array of thickness element of each zone, r_range unused [float array] (cm)
	r_in
	Initial radius [float] (cm)
	r_out
	Final radius [float] (cm)
	thickness_full
	total thickness of the nebula, r_range not used [float] (cm)
	ne_full
	array of electron density, r_range unused [float] (cm^-3)
	nH_full
	array of Hydrogen density, r_range unused [float] (cm^-3)
	te_full
	array of electron temperature, r_range unused [float] (K)
	nenH_full
	array of ne.nH, r_range unused [float] (cm^-6)
	tenenH_full
	array of te.ne.nH, r_range unused [float] (K.cm^-6)
	n_lines
	lines
	intens
	slines
	rlines
	heat_full
	cool_full
	emis_full
	opd_energy
	opd_total
	opd_absorp
	opd_scat
	n_gtemp
	gtemp_full
	gsize
	gtemp_labels
	n_gabund
	gabund_full
	gasize
	gabund_labels
	n_gdgrat
	gdgrat_full
	gdsize
	gdgrat_labels
	plan_par
	empty_model
	ff_full
	array of filling factor, r_range unused [float]
	nenHff2_full
	nHff_full
	H_mass_full
	line_labels
	emis_labels
	n_emis
	n_elements
	out
	date_model
	C3D_comments
	comments
	warnings
	cautions
	out_exists
	cloudy_version
	cloudy_version_major
	Teff
	theta
	phi
	Q
	Phi
	Q0
	Phi0
	abund
	gas_mass_per_H
Properties
	r_out_cut = property(_get_r_out_cut, _set_r_out_cut, None, _r_out_cut_doc)
	User defined outer radius of the nebula [float] (cm).
	r_in_cut = property(_get_r_in_cut, _set_r_in_cut, None, 'User defined inner radius of the nebula.')
	User defined inner radius of the nebula [float] (cm)
	H_mass_cut = property(_get_H_mass_cut, _set_H_mass_cut, None, None)

Detailed Description

Read the outputs of Cloudy into variables of the object. Also perform some computations
like T0, t2 for all the ions and lines.
Provides methods to access some outputs (e.g. continuum in various units)

The Cloudy model must have been run with the following punch or save in the input file:

set punch prefix "MODEL" (can be changed)
punch last radius ".rad"
punch last continuum ".cont"
punch last physical conditions ".phy"
punch last overview ".ovr"
punch last grain temperature ".gtemp_full"
punch last element hydrogen ".ele_H"
punch last element helium ".ele_He"
punch last element carbon ".ele_C"
punch last element nitrogen ".ele_N"
punch last element oxygen ".ele_O"
punch last element argon ".ele_Ar"
punch last element neon ".ele_Ne"
punch last element sulphur ".ele_S"
punch last element chlorin ".ele_Cl"
punch last element iron ".ele_Fe"
punch last element silicon ".ele_Si"
punch last linelist ".lin" "liste_of_lines.dat"
punch last lines emissivity ".emis"
... liste of lines  ... No need to be the same as liste_of_lines.dat
end of lines
in case of version >= 10:
save last grain abundances ".gabund_full"'
save last grain D/G ratio ".gdgrat_full"'

usage:  m1 = CloudyModel('MODEL')
plot(m1.radius,m1.get_emis('Fe_3__5271A'))
plot m1.depth,m1.te

y = 'e("TOTL__4363A")/e("O__3__5007A")'
e = lambda line: m1.get_emis(line)
plot m1.te,eval(y)

self.n_zones : number of zones Cloudy used.
self.depth : depth in cm, ndarray(n_zones)
self.radius : radius in cm, ndarray(n_zones)
self.r_in and r_out : minimum and maximum of self.radius
self.ne and nH : electron and H-densities in cm-3, ndarray(n_zones)
self.te : electron temperature in K, ndarray(n_zones)
self.nenH and tenenH : some products of the previous.
self.T0 and self.t2: mean T and t2 for H+

self.n_lines : number of emission lines in the .lin file
self.line_labels : lines names, ndarray(n_lines,dtype='S20')
self.get_line : line intensities

some lines can appear more than one time in the list of lines, they then have a _N at the end of the label.
the following deal with this:
self.slines : array of uniq values for lines (single lines)
self.n_slines : number of 
self.rlines : array of reduced labels : for duplicate lines, removing the trailing _N 

dev comments:

GPL Chris.Morisset@Gmail.com

Constructor & Destructor Documentation

def __init__	(	self,
		model_name,
		verbose = `None`,
		read_all_ext = `True`,
		read_rad = `True`,
		read_phy = `True`,
		read_emis = `True`,
		read_grains = `False`,
		read_cont = `True`,
		read_heatcool = `False`,
		read_lin = `False`,
		read_opd = `False`,
		list_elem = `LIST_ELEM`,
		distance = `None`,
		line_is_log = `False`,
		emis_is_log = `True`,
		ionic_str_key = `'ele_'`
	)

Cloudy model object.

param:
    - model_name [str] The name of the model to be read.
    - verbose [int] level of verbosity as defined by pyCloudy.my_logging.
    - read_all_ext [boolean] if True, all the extensions are read, if False no extension (empty object).
    - read_emis [boolean] if True, emissivities .emis file_ is read and interpreted.
    - read_grains [boolean] if True, grains .gtemp, .gdgrat and .gabund files are read and interpreted.
    - read_cont [boolean] if True, continuum .cont file_ is read and interpreted.
    - list_elem [list of str] list of elements X for which ionic abundance .ele_X file_ is read.
    - distance [float] distance to the nebula in kpc
    - line_is_log [boolean] if True, intensities in .lin file_ are in log, if False are in linear
    - emis_is_log [boolean] if True, intensities in .emis file_ are in log, if False are in linear

Member Function Documentation

def __repr__ ( self )

def __str__ ( self )

def cool ( self )

cooling [float array]

array of colling (on r_range)

def depth ( self )

depth [float array] (cm)

array of depth (on r_range)

def dr ( self )

size of each zone [float array] (cm)

array of dr (on r_range)

def drff ( self )

size of each zone taking into account filling factor [float array] (cm)

array of dr (on r_range)

def dv ( self )

volume of each zone [float array] (cm^3)

array of volume element (on r_range)

def dvff ( self )

volume of each zone taking into account filling factor [float array] (cm^3)

array of volume element (on r_range)

def emis_from_pyneb	(	self,
		emis_labels = `None`,
		atoms = `None`
	)

change the emissivities using PyNeb.
emis_labels: list of line to be changed. If unset, all the lines will be changed. You may generate emis_lables
    this way (here to select only S lines): S_labels = [emis for emis in CloudyModel.emis_labels if emis[0:2] == 'S_']
atoms: dictionary of pyneb.Atom objects to be used. If unset, all the atoms will be build 
    using pyneb. This allows the user to mix atomic dataset by creating atoms outside CloudyModel. Keys
    of the dictionnary pointing to None instaed of an Atom will not change the corresponding emissivities.

def ff ( self )

filling factor [float array]

array of filling factor (on r_range)

def gabund ( self )

def gdgrat ( self )

def get_ab_ion_rad	(	self,
		elem = `None`,
		ion = `None`
	)

get_ab_ion_rad(X, i) = $\frac{\int X^i/X.n_H.ff.dr}{\int n_H.ff.dr}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    Ionic fraction integrated on the radius weighted by nH

def get_ab_ion_rad_ne	(	self,
		elem = `None`,
		ion = `None`
	)

get_ab_ion_rad_ne(X, i) = $\frac{\int Xi/X.n_e.n_H.ff.dr}{\int ne.nH.ff.dr}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    ionic fraction integrated on the radius weighted by ne.nH

def get_ab_ion_vol	(	self,
		elem = `None`,
		ion = `None`
	)

get_ab_ion_vol(X, i) = $\frac{\int X^i/X.n_H.ff.dr}{\int n_H.ff.dr}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    Ionic fraction integrated on the volume weighted by hydrogen density

def get_ab_ion_vol_ne	(	self,
		elem = `None`,
		ion = `None`
	)

get_ab_ion_vol_ne(X, i) = $\frac{\int Xi/X.n_e.n_H.ff.dV}{\int ne.nH.ff.dV}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    ionic fraction integrated on the volume weighted by ne.nH

def get_cont_x	(	self,
		unit = `'Ryd'`
	)

Return the wavelength/energy/frequency array.

param:
    unit : one of ['Ryd','eV','Ang','mu','cm-1','Hz']
return:
    continuum X: wavelength, energys, wv number, or frequency

def get_cont_y	(	self,
		cont = `'incid'`,
		unit = `'es'`,
		dist_norm = `'at_earth'`
	)

param:
    cont : one of ['incid','trans','diffout','ntrans','reflec']
    unit : one of ['esc', 'ec3','es','esA','esAc','esHzc','Jy','Q', 'Wcmu']
    dist_norm : one of ['at_earth', 'r_out', a float for a distance in cm]
return:
    continuum flux or intensity

First define which of the 5 continua will be return

def get_emis	(	self,
		ref
	)

return the emissivities(radius) of the given line [array float] (erg/cm^3/s)

Return emissivity.
param:
    ref can be a label or a number (starting at 0 with the first line)

def get_emis_rad	(	self,
		ref
	)

get_emis_rad(ref) = $\int \epsilon(ref).dr$

Return integration of the emissivity on the radius
param:
    ref can be a label or a number (starting at 0 with the first line)

def get_emis_vol	(	self,
		ref,
		at_earth = `False`
	)

get_emis_vol(ref, [at_earth]) = $\int \epsilon(ref).dV [/ 4.\pi.(distance)^2]$

Return integration of the emissivity on the volume (should be the line intensity if r_out_cut>=r_out)
param:
    ref can be a label or a number (starting at 0 with the first line)

def get_G0	(	self,
		lam_min = `913`,
		lam_max = `1e8`,
		dist_norm = `'r_out'`,
		norm = `1.6e-6`,
		unit = `'Wm'`
	)

get_G0 = integral(f_lambda .

dlambda) Between lam_min and lam_max (Ang), normalized by norm, in unit of W.m-2 or erg.cm-3

def get_Hb_SB ( self )

Hb_SB = I$_ / (Rout^2 * pi * 206265.

^2)$

Hbeta surface brightness:
Returns Ibeta / (Rout**2 * pi * 206265.**2)

def get_ionic	(	self,
		elem,
		ion
	)

param
    elem [str] element
    ion [str or int] ionic state of ion
return: 
    ionic fraction of (elem, ion).

def get_line	(	self,
		ref
	)

Return line intensity.
ref can be a label or a number (starting at 0 with the first line)

def get_ne_emis	(	self,
		ref
	)

get_ne_emis(ref) = $\frac{\int n_e.\epsilon(ref).dV}{\int \epsilon(ref).dV}$

integral of the electron density on the volume, weighted by emissivity of a given line
param:
    ref [int or str] line reference
return:
    [float]

def get_ne_ion_rad_ne	(	self,
		elem = `None`,
		ion = `None`
	)

get_ne_ion_rad_ne(X, i) = $\frac{\int ne.ne.nH.ff.Xi/X.dr}{\int ne.nH.ff.Xi/X.dr}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    electron density integrated on the radius weighted by ne.nH.Xi/X

def get_ne_ion_vol_ne	(	self,
		elem = `None`,
		ion = `None`
	)

get_ne_ion_vol_ne(X, i) = $\frac{\int ne.ne.nH.ff.Xi/X.dV}{\int ne.nH.ff.Xi/X.dV}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    electron density integrated on the volume weighted by ne.nH.Xi/X

def get_T0_emis	(	self,
		ref
	)

get_T0_emis(ref) = $\frac{\int T_e.\epsilon(ref).dV}{\int \epsilon(ref).dV}$

integral of the electron temperature on the volume, weighted by emissivity of a given line
param:
    ref [int or str] line reference
return:
    [float]

def get_T0_emis_rad	(	self,
		ref
	)

get_T0_emis_rad(ref) = $\frac{\int T_e.\epsilon(ref).dr}{\int \epsilon(ref).dr}$

integral of the electron temperature on the radius, weighted by emissivity of a given line
param:
    ref [int or str] line reference
return:
    [float]

def get_T0_ion_rad	(	self,
		elem = `None`,
		ion = `None`
	)

get_T0_ion_rad(X, i) = $\frac{\int T_e.n_H.ff.X^i/X.dr}{\int n_H.ff.X^i/X.dr}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    Electron temperature integrated on the radius weighted by ionic abundance

def get_T0_ion_rad_ne	(	self,
		elem = `None`,
		ion = `None`
	)

get_T0_ion_rad_ne(X, i) = $\frac{\int Te.ne.nH.ff.Xi/X.dr}{\int ne.nH.ff.Xi/X.dr}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    electron temperature integrated on the radius weighted by ne.nH.Xi/X

def get_T0_ion_vol	(	self,
		elem = `None`,
		ion = `None`
	)

get_T0_ion_vol(X, i) = $\frac{\int T_e.n_H.ff.X^i/X.dV}{\int n_H.ff.X^i/X.dV}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    Electron temperature integrated on the volume weighted by ionic abundance

def get_T0_ion_vol_ne	(	self,
		elem = `None`,
		ion = `None`
	)

get_T0_ion_vol_ne(X, i) = $\frac{\int Te.ne.nH.ff.Xi/X.dV}{\int ne.nH.ff.X^i/X.dV}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    electron temperature integrated on the volume weighted by ne.nH.Xi/X

def get_t2_emis	(	self,
		ref
	)

get_t2_emis(ref) = $\frac{\int (T_e-T(ref))^2.\epsilon(ref).dV}{T(ref)^2\int \epsilon(ref).dV}$

t2(emissivity) integrated on the volume, weigthed by the emissivity
param:
    ref [int or str] line reference
return:
    [float]

def get_t2_ion_rad_ne	(	self,
		elem = `None`,
		ion = `None`
	)

get_t2_ion_vol_ne(X, i) = $\frac{\int (T_e-T_{X^i})^2.n_e.n_H.ff.X^i/X.dr}{T_{X^i}^2.\int ne.nH.ff.X^i/X.dr}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    t2 integrated on the radius weighted by ne.nH.X^i/X

def get_t2_ion_vol_ne	(	self,
		elem = `None`,
		ion = `None`
	)

get_t2_ion_vol_ne(X, i) = $\frac{\int (T_e-T_{X^i})^2.n_e.n_H.ff.X^i/X.dV}{T_{X^i}^2.\int ne.nH.ff.X^i/X.dV}$

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    t2 integrated on the volume weighted by ne.nH.X^i/X

def gtemp ( self )

def H0_mass ( self )

H0_mass = $\int m_H.n_{H^0}.ff.dV$ [solar mass].

Return the H0 mass of the nebula in solar mass

def H_mass ( self )

H0_mass = $\int m_H.n_H.ff.dV$ [solar mass].

Return the H mass of the nebula in solar mass

def heat ( self )

heating [float array]

array of heating (on r_range)

def Hp_mass ( self )

Hp_mass = $\int m_H.n_{H^+}.ff.dV$ [solar mass].

Return the H+ mass of the nebula in solar mass

def is_valid_ion	(	self,
		elem,
		ion
	)

is_valid_ion(elem, ion) return True if elem, ion is available in get_ionic.

param:
    elem [str] element
    ion [str or int] ionic state of ion
return:    
    [boolean] True if elem,ion has value for get_ionic(elem, ion)

def log_U ( self )

log(U) in each zone [float array], with U(r) = $Q_0 / (4.\pi.r^2.n_H.c)$

U = Q0 /(4 pi radius**2 nH c)

def log_U_mean ( self )

log_U_mean = $\frac{\int U.dV}{\int dV}$ [float]

log of mean value of U on the volume

def log_U_mean_ne ( self )

log_U_mean_ne = $\frac{\int U.ne.dV}{\int ne.dV}$ [float]

log of mean value of U on the volume

def n_zones ( self )

number of zones [int]

def ne ( self )

electron density [float array] (cm^-3)

array of electron density (on r_range)

def nenH ( self )

ne.nH [float array] (cm^-6)

array of ne.nH (on r_range)

def nH ( self )

Hydrogen density [float array] (cm^-3)

array of Hydrogen density (on r_range)

def nH_mean ( self )

mean of the Hydrogen density over the volume
return:
    [float]

def print_lines	(	self,
		ref = `None`,
		norm = `None`,
		at_earth = `False`,
		use_emis = `True`
	)

Print line intensities
param:
    at_earth [boolean] if True, divide the intensity by 4.pi.distance^2
    ref [int or str] reference of a line (if None, all lines are printed)
    norm [int or str] reference of a line to normalize the intensities

def print_stats ( self )

def r_range ( self )

Boolean array defining the range used for the radial parameters (such as ne, ionic, integrals, etc) Defined by r_in_cut and r_out_cut.

boolean array. True for r_in_cut < radius < r_out_cut, False elsewhere.
Used in most of the parameter calls such as te, get_emis, get_ionic, etc

def rad_integ	(	self,
		a
	)

rad_integ(a) = $\int a.ff.dr$

integral of a on the radius

def rad_mean	(	self,
		a,
		b = `1.`
	)

rad_mean(a, b) = $\frac{\int a.b.dr}{\int b.dr}$

Return the mean value of a weighted by b on the radius

def radius ( self )

radius [float array] (cm)

array of radius (on r_range)

def read_outputs	(	self,
		extension,
		delimiter = `'\t'`,
		comments = `';'`,
		names = `True`,
		kwargs
	)

def T0 ( self )

Mean Temperature $T0=\frac{\int T_e.n_e.n_H.ff.dV}{\int n_e.n_H.ff.dV}$ .

def t2 ( self )

t2 a la Peimbert $t^2=\frac{\int (T_e-T0)^2.n_e.n_H.ff.dV}{T0^2 \int n_e.n_H.ff.dV}$

def te ( self )

Electron temperature [float array] (K)

array of electron temperature (on r_range)

def tenenH ( self )

te.ne.nH [float array] (K.cm^-6)

array of Te.ne.nH (on r_range)

def thickness ( self )

thickness [float array] (cm)

array of thickness (on r_range)

def vol_integ	(	self,
		a
	)

vol_integ(a) = $\int a.ff.dV$

integral of a on the volume

def vol_mean	(	self,
		a,
		b = `1.`
	)

vol_mean(a, b) = $\frac{\int a.b.ff.dV}{\int b.ff.dV}$

Return the mean value of a weighted by b on the volume

def zones ( self )

array of zones [int array]

Member Data Documentation

array of depths, r_range unused [float array] (cm)

distance

distance to the object (kpc)

dr_full

array of thickness element of each zone, r_range unused [float array] (cm)

dv_full

array of volume element of each zone, r_range unused [float array] ( $cm^3$ )

array of filling factor, r_range unused [float]

logging tool [my_logging object]

model_name

name of the model [str]

total number of zones, r_range unused [int]

ne_full

array of electron density, r_range unused [float] (cm^-3)

nenH_full

array of ne.nH, r_range unused [float] (cm^-6)

nenHff2_full

nH_full

array of Hydrogen density, r_range unused [float] (cm^-3)

Initial radius [float] (cm)

r_out

Final radius [float] (cm)

radius_full

array of radius, r_range unused [float array] (cm)

rlines

slines

te_full

array of electron temperature, r_range unused [float] (K)

Teff

tenenH_full

array of te.ne.nH, r_range unused [float] (K.cm^-6)

theta

thickness_full

total thickness of the nebula, r_range not used [float] (cm)

warnings

zones_full

arrays of zones, r_range unused [int array]

Property Documentation

H_mass_cut = property(_get_H_mass_cut, _set_H_mass_cut, None, None) [static]

r_in_cut = property(_get_r_in_cut, _set_r_in_cut, None, 'User defined inner radius of the nebula.') [static]

User defined inner radius of the nebula [float] (cm)

r_out_cut = property(_get_r_out_cut, _set_r_out_cut, None, _r_out_cut_doc) [static]

User defined outer radius of the nebula [float] (cm).

For example: r_out_cut = m.radius[m.zones[m.ionic['H'][1] < 0.2][0]]. It is used to define r_range and thus all the radial properties of the nebula

Public Member Functions

Public Attributes

Properties

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation