PyNeb  1.1.2
PyNeb Reference Manua
RedCorr Class Reference

Inherits object.

Public Member Functions

def __init__
 
def cHbetaFromEbv (self, ebv)
 
def EbvFromCHbeta (self, cHbeta)
 
def getLaws (self)
 
def printLaws (self)
 
def getCorr
 
def getCorrHb (self, wave)
 
def getErrCorr
 
def getErrCorrHb (self, wave, err_E_BV)
 
def setCorr (self, obs_over_theo, wave1, wave2)
 
def plot (self, w_inf=1000., w_sup=10000., laws=None, ax=None, kwargs)
 

Public Attributes

 log_
 
 calling
 
 UserParams
 
 FitzParams
 
 X
 

Properties

 E_BV = property(_get_e_bv, _set_e_bv, None, None)
 
 R_V = property(_get_r_v, _set_r_v, None, None)
 
 law = property(_get_law, _set_law, None, None)
 
 cHbeta = property(_get_cHbeta, _set_cHbeta, None, None)
 
 AV = property(_get_AV, _set_AV, None, None)
 
 UserFunction = property(_get_uf, _set_uf, None, None)
 

Detailed Description

Reddening correction
RC = RedCorr()

Constructor & Destructor Documentation

def __init__ (   self,
  E_BV = 0.,
  R_V = 3.1,
  law = 'No correction',
  cHbeta = None,
  UserFunction = None 
)
Reddening correction tool.

Usage:
    RC = RedCorr(E_BV = 1.)
    RC.plot(laws = 'all')

    def my_X(wave, params = [5000., 1., 2., 3.]):
\

Member Function Documentation

def cHbetaFromEbv (   self,
  ebv 
)
Return cHbeta from E(BV)
Usage: 
    (1-f_lambda).cHbeta = 0.4.EBV.X_lambda applied to lambda = 4861, with f_beta = 0.:
    cHbeta = 0.4 . EBV . X_beta

Parameter:
    - ebv    E(B-V)
def EbvFromCHbeta (   self,
  cHbeta 
)
Return E(B-V) from cHbeta
Using: 
    (1-f_lambda).cHbeta = 0.4.EBV.X_lambda applied to lambda = 4861, with f_beta = 0.:
    cHbeta = 0.4 . EBV . X_beta

Parameter:
    - cHbeta
def getCorr (   self,
  wave,
  rel_wave = None 
)
Return the extinction correction as:
    correction = 10**(0.4 * EBV * Xx) = 10**(A_lambda / 2.5)

Usage:
    RC.getCorr(5007)
    RC.getCorr(5007, 4861)
    
Parameters:
    - wave      wavelength (Angstrom)
    - rel_wave  wavelength (Angstrom) for a relative correction
def getCorrHb (   self,
  wave 
)
Return the extinction correction normalized to the correction at 4861AA.
    
Parameter:
    - wave      wavelength (Angstrom)
def getErrCorr (   self,
  wave,
  err_E_BV,
  rel_wave = None 
)
Return the error on the correction for a given wavelength, given the error on E(B-V)

Parameters:
    - wave         wavelength(s)
    - err_E_BV     error on E(B-V)
    - rel_wave     reference wavelength for the normalization (optional)
def getErrCorrHb (   self,
  wave,
  err_E_BV 
)
Return the the error on the correction relative to Hbeta for a given wavelength, 
    given the error on E(B-V)

Parameters:
    - wave         wavelength(s)
    - err_E_BV     error on E(B-V)
def getLaws (   self)
Return the dictionary keys for the extinction laws
def plot (   self,
  w_inf = 1000.,
  w_sup = 10000.,
  laws = None,
  ax = None,
  kwargs 
)
Plot extinction laws

Parameters:
    - w_inf [float] lower limit of plot
    - w_sup [float] upper limit of plot
    - laws [list of strings] list of extinction law labels. If set to 'all', all the laws are plotted
    - ax : an axis object. If None, onr is created
    - **kwargs arguments to plot
def printLaws (   self)
Print out the extinction laws
def setCorr (   self,
  obs_over_theo,
  wave1,
  wave2 
)
Determination of the correction using the ratio of two observed line intensities 
    relative to the theoretical value.

Usage:
    rc.setCorr(6.5/2.85, 6563., 4861.)
    
Parameters:
    - obs_over_theo    ration of the observed ratio over the theoretical ratio
    - wave1, wave2     wavelengths at which the line rations are taken.

Member Data Documentation

calling
FitzParams
log_
UserParams
X

Property Documentation

AV = property(_get_AV, _set_AV, None, None)
static
cHbeta = property(_get_cHbeta, _set_cHbeta, None, None)
static
E_BV = property(_get_e_bv, _set_e_bv, None, None)
static
law = property(_get_law, _set_law, None, None)
static
R_V = property(_get_r_v, _set_r_v, None, None)
static
UserFunction = property(_get_uf, _set_uf, None, None)
static