def measure_aodm(self, nsig=3., normalize=True):
""" AODM calculation
It sets these attributes:
* self.attrib[ 'N', 'sig_N', 'logN', 'sig_logN' ]:
Column densities and errors, linear and log
Parameters
----------
nsig : float, optional
Number of sigma significance required for a "detection"
normalize : bool, optional
Normalize first?
"""
# Cut spectrum
fx, sig, xdict = self.cut_spec(normalize=normalize)
velo = xdict['velo']
# Check that there is sufficient data
if len(fx) <= 1:
warnings.warn("Spectrum does not cover {:g}".format(self.wrest))
self.attrib['flag_N'] = 0
return
# Calculate
N, sig_N, flg_sat = laa.aodm((velo, fx, sig),
(self.wrest, self.data['f']))
# Flag
if flg_sat:
self.attrib['flag_N'] = 2
else:
if N > nsig * sig_N:
self.attrib['flag_N'] = 1
else:
self.attrib['flag_N'] = 3
# Values
self.attrib['N'] = N
self.attrib['sig_N'] = sig_N
# Log
laa.log_clm(self.attrib)
def measure_aodm(self, nsig=3., normalize=True):
""" AODM calculation
It sets these attributes:
* self.attrib[ 'N', 'sig_N', 'logN', 'sig_logN' ]:
Column densities and errors, linear and log
Parameters
----------
nsig : float, optional
Number of sigma significance required for a "detection"
normalize : bool, optional
Normalize first?
"""
# Cut spectrum
fx, sig, xdict = self.cut_spec(normalize=normalize)
velo = xdict['velo']
# Check that there is sufficient data
if len(fx) <= 1:
warnings.warn("Spectrum does not cover {:g}".format(self.wrest))
self.attrib['flag_N'] = 0
return
# Calculate
N, sig_N, flg_sat = laa.aodm((velo, fx, sig), (self.wrest,self.data['f']))
# Flag
if flg_sat:
self.attrib['flag_N'] = 2
else:
if N > nsig*sig_N:
self.attrib['flag_N'] = 1
else:
self.attrib['flag_N'] = 3
# Values
self.attrib['N'] = N
self.attrib['sig_N'] = sig_N
# Log
laa.log_clm(self.attrib)
def measure_aodm(self, nsig=3.):
""" AODM calculation
It sets these attributes:
* self.attrib[ 'N', 'sigN', 'logN', 'sig_logN' ]:
Column densities and errors, linear and log
Parameters
----------
nsig : float, optional
Number of sigma significance required for a "detection"
"""
# Cut spectrum
fx, sig, xdict = self.cut_spec(normalize=True)
velo = xdict['velo']
# Calculate
N,sigN,flg_sat = laa.aodm( (velo, fx, sig), (self.wrest,self.data['f']) )
# Flag
if flg_sat:
self.attrib['flagN'] = 2
else:
if N > nsig*sigN:
self.attrib['flagN'] = 1
else:
self.attrib['flagN'] = 3
# Values
self.attrib['N'] = N
self.attrib['sigN'] = sigN
# Log
logN, sig_logN = laa.log_clm(self.attrib)
self.attrib['logN'] = logN # Dimensionless
self.attrib['sig_logN'] = sig_logN # Dimensionless
def synthesize_colm(self, overwrite=False, redo_aodm=False, **kwargs):
"""Synthesize column density measurements of the component.
Default is to use the current AbsLine values, but the user can
request that those be re-calculated with AODM.
Parameters
----------
overwrite : bool, optional
Clobber any previous measurement
redo_aodm : bool, optional
Redo the individual column density measurements (likely AODM)
Returns
-------
None
Fills the component attributes instead
"""
# Check
if (self.flag_N != 0) and (not overwrite):
raise IOError("Column densities already set. Use overwrite=True to redo.")
# Redo?
if redo_aodm:
for aline in self._abslines:
aline.measure_aodm(**kwargs)
# Collate
self.flag_N = 0
for aline in self._abslines:
if aline.attrib['flag_N'] == 0: # No value
warnings.warn("Absline {} has flag=0. Hopefully you expected that".format(str(aline)))
continue
# Check N is filled
if np.allclose(aline.attrib['N'].value, 0.):
raise ValueError("Need to set N in attrib. \n Consider linear_clm in linetools.analysis.absline")
if aline.attrib['flag_N'] == 1: # Good value?
if self.flag_N == 1: # Weighted mean
# Original
weight = 1. / self.sig_N**2
mu = self.N * weight
# Update
weight += 1./aline.attrib['sig_N']**2
self.N = (mu + aline.attrib['N']/aline.attrib['sig_N']**2) / weight
self.sig_N = np.sqrt(1./weight)
else: # Fill
self.N = aline.attrib['N']
self.sig_N = aline.attrib['sig_N']
self.flag_N = 1
elif aline.attrib['flag_N'] == 2: # Lower limit
if self.flag_N in [0, 3]:
self.N = aline.attrib['N']
self.sig_N = aline.attrib['sig_N']
self.flag_N = 2
elif self.flag_N == 2:
if aline.attrib['N'] > self.N:
self.N = aline.attrib['N']
self.sig_N = aline.attrib['sig_N']
elif self.flag_N == 1:
pass
elif aline.attrib['flag_N'] == 3: # Upper limit
if self.flag_N == 0:
self.N = aline.attrib['N']
self.sig_N = aline.attrib['sig_N']
self.flag_N = 3
elif self.flag_N in [1, 2]:
pass
elif self.flag_N == 3:
if aline.attrib['N'] < self.N:
self.N = aline.attrib['N']
self.sig_N = aline.attrib['sig_N']
elif aline.attrib['flag_N'] == 0: # No value
warnings.warn("Absline {} has flag=0. Hopefully you expected that")
else:
raise ValueError("Bad flag_N value")
# Log values
if self.flag_N > 0:
self.logN, self.sig_logN = ltaa.log_clm(self)
def from_abslines(cls,
abslines,
stars=None,
comment="",
reliability='none',
skip_synth=False,
adopt_median=False,
tol=0.01,
chk_meas=False,
verbose=True,
**kwargs):
"""Instantiate from a list of AbsLine objects
If the AbsLine objects contain column density measurements,
these will be synthesized in one of two ways (controlled by adopt_median)
Parameters
----------
abslines : list
List of AbsLine objects
stars : str, optional
Asterisks to append to the ion name (e.g. fine-structure, CII*)
comment : str
A comment associated to the resulting AbsComponent
Default is `""`
reliability : str, optional
Reliability of AbsComponent
'a' - reliable
'b' - possible
'c' - uncertain
'none' - not defined (default)
skip_synth : bool, optional
Skip synthesizing the column densities (and more) of the AbsLine objects
adopt_median : bool, optional
Adopt median values for N, b, vel from the AbsLine objects
Otherwise, use synthesize_colm for the column densities
chk_meas : bool, optional
If true, require that measurements for lines composing a component
have matching values before setting component attribs.
Otherwise, throw a warning
tol : float, optional
Fractional tolerance for line attributes (N,b) to match one another
Only applied if chk_meas=True and adopt_median=True
**kwargs -- Passed to add_absline
"""
from linetools.analysis import absline as ltaa
# Check
if not isinstance(abslines, list):
raise IOError("Need a list of AbsLine objects")
if not all(isinstance(x, AbsLine) for x in abslines):
raise IOError("List needs to contain only AbsLine objects")
# Instantiate with the first line
init_line = abslines[0]
slf = cls(init_line.attrib['coord'],
(init_line.data['Z'], init_line.data['ion']),
init_line.z,
init_line.limits.vlim,
Ej=init_line.data['Ej'],
stars=stars,
reliability=reliability,
comment=comment)
slf._abslines.append(init_line)
# Append with component checking
if len(abslines) > 1:
for absline in abslines[1:]:
slf.add_absline(absline, **kwargs)
### Synthesize column density (and more)
if not skip_synth:
if not adopt_median:
slf.synthesize_colm(**kwargs)
else:
# First check that the measurements for all the lines match
# Grab them all
cols = np.array([al.attrib['N'].value for al in abslines])
colerrs = np.array(
[al.attrib['sig_N'].value for al in abslines])
bs = np.array([al.attrib['b'].value for al in abslines])
berrs = np.array([al.attrib['sig_b'].value for al in abslines])
vels = np.array([al.attrib['vel'].value for al in abslines])
velerrs = np.array(
[al.attrib['sig_vel'].value for al in abslines])
medcol = np.median(cols)
medcolerr = np.median(colerrs, axis=0)
medb = np.median(bs)
medberr = np.median(berrs)
medvel = np.median(vels)
medvelerr = np.median(velerrs)
# Perform checks on measurements
if medcol == 0.:
colcrit = np.all((cols) == 0.)
else:
colcrit = all(np.abs(cols - medcol) / medcol < tol) is True
if medb == 0.:
bcrit = np.all((bs) == 0.)
else:
bcrit = all(np.abs(bs - medb) / medb < tol) is True
# Assign appropriate flag
flags = np.array([al.attrib['flag_N'] for al in abslines])
if 1 in flags: # Any of the lines is detected and unsaturated
slf.attrib['flag_N'] = 1
elif np.all(flags == 3): # All of the lines are upper limits
slf.attrib['flag_N'] = 3
elif 2 in flags: # Any of the lines is saturated
slf.attrib['flag_N'] = 2
elif np.all(
flags == 0): # Something else, e.g., line not covered
slf.attrib['flag_N'] = 0
else:
raise ValueError("AbsLine flag_N values conflict. Cannot"
" instantiate AbsComponent.")
# Set attribs
slf.attrib['N'] = medcol / u.cm**2
slf.attrib['sig_N'] = medcolerr / u.cm**2
slf.attrib['b'] = medb * u.km / u.s
slf.attrib['sig_b'] = medberr * u.km / u.s
slf.attrib['vel'] = medvel * u.km / u.s
slf.attrib['sig_vel'] = medvelerr * u.km / u.s
logN, sig_logN = ltaa.log_clm(slf.attrib)
slf.attrib['logN'] = logN
slf.attrib['sig_logN'] = sig_logN
# Stop or throw warnings
if (bcrit & colcrit):
pass
else:
if verbose or chk_meas:
if bcrit:
print(
'A problem lies in the column density values')
elif colcrit:
print('A problem lies in the b values')
else:
print(
'Problems lie in the column densities and b values'
)
if chk_meas:
raise ValueError(
'The line measurements for the lines in this '
'component are not consistent with one another.'
)
else:
warnings.warn(
'The line measurements for the lines in this component'
' may not be consistent with one another.')
# Return
return slf
def synthesize_colm(self,
overwrite=False,
redo_aodm=False,
debug=False,
**kwargs):
"""Synthesize column density measurements of the component.
Default is to use the current AbsLine values, but the user can
request that those be re-calculated with AODM.
Currently, the weighted mean is performed by taking the average
error given in sig_N which is a 2-element array.
Parameters
----------
overwrite : bool, optional
Clobber any previous measurement
redo_aodm : bool, optional
Redo the individual column density measurements (likely AODM)
Returns
-------
None
Fills the component attributes instead
"""
# Check
if (self.flag_N != 0) and (not overwrite):
raise IOError(
"Column densities already set. Use overwrite=True to redo.")
# Redo?
if redo_aodm:
for aline in self._abslines:
aline.measure_aodm(**kwargs)
# Collate
self.attrib['flag_N'] = 0
if debug:
pdb.set_trace()
for aline in self._abslines:
if aline.attrib['flag_N'] == 0: # No value
warnings.warn(
"Absline {} has flag=0. Hopefully you expected that".
format(str(aline)))
continue
# Check N is filled
if np.isclose(aline.attrib['N'].value, 0.):
raise ValueError(
"Need to set N in attrib. \n Consider linear_clm in linetools.analysis.absline"
)
if aline.attrib['flag_N'] == 1: # Good value?
if self.flag_N == 1: # Weighted mean
# Original
weight = 1. / np.mean(self.sig_N)**2
mu = self.N * weight
# Update
weight += 1. / np.mean(aline.attrib['sig_N'])**2
self.attrib['N'] = (mu + aline.attrib['N'] / np.mean(
aline.attrib['sig_N'])**2) / weight
self.attrib['sig_N'] = Quantity([np.sqrt(1. / weight)] * 2)
else: # Fill
self.attrib['N'] = aline.attrib['N']
self.attrib['sig_N'] = aline.attrib['sig_N']
self.attrib['flag_N'] = 1
elif aline.attrib['flag_N'] == 2: # Lower limit
if self.flag_N in [0, 3]:
self.attrib['N'] = aline.attrib['N']
self.attrib['sig_N'] = aline.attrib['sig_N']
self.attrib['flag_N'] = 2
elif self.flag_N == 2:
if aline.attrib['N'] > self.N:
self.attrib['N'] = aline.attrib['N']
self.attrib['sig_N'] = aline.attrib['sig_N']
elif self.flag_N == 1:
pass
elif aline.attrib['flag_N'] == 3: # Upper limit
if self.flag_N == 0:
self.attrib['N'] = aline.attrib['N']
self.attrib['sig_N'] = aline.attrib['sig_N']
self.attrib['flag_N'] = 3
elif self.flag_N in [1, 2]:
pass
elif self.flag_N == 3:
if aline.attrib['N'] < self.N:
self.attrib['N'] = aline.attrib['N']
self.attrib['sig_N'] = aline.attrib['sig_N']
elif aline.attrib['flag_N'] == 0: # No value
warnings.warn(
"Absline {} has flag=0. Hopefully you expected that")
else:
raise ValueError("Bad flag_N value")
# Enforce 2-element error arrays
if self.attrib['sig_N'].size == 1:
self.attrib['sig_N'] = [self.attrib['sig_N'].value
] * 2 * self.attrib['sig_N'].unit
# Log values
if self.flag_N > 0:
_, _ = ltaa.log_clm(self.attrib)
def synthesize_colm(self, overwrite=False, redo_aodm=False, **kwargs):
"""Synthesize column density measurements of the component.
Default is to use the current AbsLine values, but the user can
request that those be re-calculated with AODM
Parameters
----------
overwrite : bool, optional
Clobber any previous measurement
redo_aodm : bool, optional
Redo the individual column density measurements (likely AODM)
Returns
-------
None
Fills the component attributes instead
"""
# Check
if (self.flgN != 0) and (not overwrite):
raise IOError("Column densities already set. Use clobber=True to redo.")
# Redo?
if redo_aodm:
for aline in self._abslines:
aline.measure_aodm(**kwargs)
# Collate
self.flgN = 0
for aline in self._abslines:
if aline.attrib['flagN'] == 1: # Good value?
if self.flgN == 1: # Weighted mean
# Original
weight = 1. / self.sigN**2
mu= self.N * weight
# Update
weight += 1./aline.attrib['sigN']**2
self.N = (mu + aline.attrib['N']/aline.attrib['sigN']**2) / weight
self.sigN = np.sqrt(1./weight)
else: # Fill
self.N = aline.attrib['N']
self.sigN = aline.attrib['sigN']
self.flgN = 1
elif aline.attrib['flagN'] == 2: # Lower limit
if self.flgN in [0,3]:
self.N = aline.attrib['N']
self.sigN = 99.
self.flgN = 2
elif self.flgN == 2:
self.N = max(self.N,aline.attrib['N'])
self.sigN = 99.
elif self.flgN == 1:
pass
elif aline.attrib['flagN'] == 3: # Upper limit
if self.flgN == 0:
self.N = aline.attrib['N']
self.sigN = aline.attrib['sigN']
self.flgN = 3
elif self.flgN in [1,2]:
pass
elif self.flgN == 3:
if aline.attrib['N'] < self.N:
self.N = aline.attrib['N']
self.sigN = aline.attrib['sigN']
else:
raise ValueError("Bad flagN value")
# Log values
self.logN, self.sig_logN = ltaa.log_clm(self)
def test_logclm():
obj = type(str('Dummy'), (object,), { str('N'): 1e13, str('sig_N'): 5e12 })
#
logN, sig_logN = log_clm(obj)
np.testing.assert_allclose(logN, 13.)
def from_abslines(cls, abslines, stars=None, comment="", reliability='none',
skip_synth=False,
adopt_median=False, tol=0.01, chk_meas=False, verbose=True, **kwargs):
"""Instantiate from a list of AbsLine objects
If the AbsLine objects contain column density measurements,
these will be synthesized in one of two ways (controlled by adopt_median)
Parameters
----------
abslines : list
List of AbsLine objects
stars : str, optional
Asterisks to append to the ion name (e.g. fine-structure, CII*)
comment : str
A comment associated to the resulting AbsComponent
Default is `""`
reliability : str, optional
Reliability of AbsComponent
'a' - reliable
'b' - possible
'c' - uncertain
'none' - not defined (default)
skip_synth : bool, optional
Skip synthesizing the column densities (and more) of the AbsLine objects
adopt_median : bool, optional
Adopt median values for N, b, vel from the AbsLine objects
Otherwise, use synthesize_colm for the column densities
chk_meas : bool, optional
If true, require that measurements for lines composing a component
have matching values before setting component attribs.
Otherwise, throw a warning
tol : float, optional
Fractional tolerance for line attributes (N,b) to match one another
Only applied if chk_meas=True and adopt_median=True
**kwargs -- Passed to add_absline
"""
from linetools.analysis import absline as ltaa
# Check
if not isinstance(abslines, list):
raise IOError("Need a list of AbsLine objects")
if not all(isinstance(x, AbsLine) for x in abslines):
raise IOError("List needs to contain only AbsLine objects")
# Instantiate with the first line
init_line = abslines[0]
slf = cls( init_line.attrib['coord'], (init_line.data['Z'],init_line.data['ion']),
init_line.z, init_line.limits.vlim,
Ej=init_line.data['Ej'], stars=stars, reliability=reliability, comment=comment)
slf._abslines.append(init_line)
# Append with component checking
if len(abslines) > 1:
for absline in abslines[1:]:
slf.add_absline(absline, **kwargs)
### Synthesize column density (and more)
if not skip_synth:
if not adopt_median:
slf.synthesize_colm(**kwargs)
else:
# First check that the measurements for all the lines match
# Grab them all
cols = np.array([al.attrib['N'].value for al in abslines])
colerrs = np.array([al.attrib['sig_N'].value for al in abslines])
bs = np.array([al.attrib['b'].value for al in abslines])
berrs = np.array([al.attrib['sig_b'].value for al in abslines])
vels = np.array([al.attrib['vel'].value for al in abslines])
velerrs = np.array([al.attrib['sig_vel'].value for al in abslines])
medcol = np.median(cols)
medcolerr = np.median(colerrs, axis=0)
medb = np.median(bs)
medberr = np.median(berrs)
medvel = np.median(vels)
medvelerr = np.median(velerrs)
# Perform checks on measurements
if medcol == 0.:
colcrit = np.all((cols) == 0.)
else:
colcrit = all(np.abs(cols - medcol) / medcol < tol) is True
if medb == 0.:
bcrit = np.all((bs) == 0.)
else:
bcrit = all(np.abs(bs - medb) / medb < tol) is True
# Assign appropriate flag
flags = np.array([al.attrib['flag_N'] for al in abslines])
if 1 in flags: # Any of the lines is detected and unsaturated
slf.attrib['flag_N'] = 1
elif np.all(flags == 3): # All of the lines are upper limits
slf.attrib['flag_N'] = 3
elif 2 in flags: # Any of the lines is saturated
slf.attrib['flag_N'] = 2
elif np.all(flags == 0): # Something else, e.g., line not covered
slf.attrib['flag_N'] = 0
else:
raise ValueError("AbsLine flag_N values conflict. Cannot"
" instantiate AbsComponent.")
# Set attribs
slf.attrib['N'] = medcol / u.cm ** 2
slf.attrib['sig_N'] = medcolerr / u.cm ** 2
slf.attrib['b'] = medb * u.km / u.s
slf.attrib['sig_b'] = medberr * u.km / u.s
slf.attrib['vel'] = medvel * u.km / u.s
slf.attrib['sig_vel'] = medvelerr * u.km / u.s
logN, sig_logN = ltaa.log_clm(slf.attrib)
slf.attrib['logN'] = logN
slf.attrib['sig_logN'] = sig_logN
# Stop or throw warnings
if (bcrit&colcrit):
pass
else:
if verbose or chk_meas:
if bcrit:
print('A problem lies in the column density values')
elif colcrit:
print('A problem lies in the b values')
else:
print('Problems lie in the column densities and b values')
if chk_meas:
raise ValueError('The line measurements for the lines in this '
'component are not consistent with one another.')
else:
warnings.warn('The line measurements for the lines in this component'
' may not be consistent with one another.')
# Return
return slf
def synthesize_colm(self, overwrite=False, redo_aodm=False, debug=False, **kwargs):
"""Synthesize column density measurements of the component.
Default is to use the current AbsLine values, but the user can
request that those be re-calculated with AODM.
Currently, the weighted mean is performed by taking the average
error given in sig_N which is a 2-element array.
Parameters
----------
overwrite : bool, optional
Clobber any previous measurement
redo_aodm : bool, optional
Redo the individual column density measurements (likely AODM)
Returns
-------
None
Fills the component attributes instead
"""
# Check
if (self.flag_N != 0) and (not overwrite):
raise IOError("Column densities already set. Use overwrite=True to redo.")
# Redo?
if redo_aodm:
for aline in self._abslines:
aline.measure_aodm(**kwargs)
# Collate
self.attrib['flag_N'] = 0
if debug:
pdb.set_trace()
for aline in self._abslines:
if aline.attrib['flag_N'] == 0: # No value
warnings.warn("Absline {} has flag=0. Hopefully you expected that".format(str(aline)))
continue
# Check N is filled
if np.isclose(aline.attrib['N'].value, 0.):
raise ValueError("Need to set N in attrib. \n Consider linear_clm in linetools.analysis.absline")
if aline.attrib['flag_N'] == 1: # Good value?
if self.flag_N == 1: # Weighted mean
# Original
weight = 1. / np.mean(self.sig_N)**2
mu = self.N * weight
# Update
weight += 1./np.mean(aline.attrib['sig_N'])**2
self.attrib['N'] = (mu + aline.attrib['N']/np.mean(aline.attrib['sig_N'])**2) / weight
self.attrib['sig_N'] = Quantity([np.sqrt(1./weight)]*2)
else: # Fill
self.attrib['N'] = aline.attrib['N']
self.attrib['sig_N'] = aline.attrib['sig_N']
self.attrib['flag_N'] = 1
elif aline.attrib['flag_N'] == 2: # Lower limit
if self.flag_N in [0, 3]:
self.attrib['N'] = aline.attrib['N']
self.attrib['sig_N'] = aline.attrib['sig_N']
self.attrib['flag_N'] = 2
elif self.flag_N == 2:
if aline.attrib['N'] > self.N:
self.attrib['N'] = aline.attrib['N']
self.attrib['sig_N'] = aline.attrib['sig_N']
elif self.flag_N == 1:
pass
elif aline.attrib['flag_N'] == 3: # Upper limit
if self.flag_N == 0:
self.attrib['N'] = aline.attrib['N']
self.attrib['sig_N'] = aline.attrib['sig_N']
self.attrib['flag_N'] = 3
elif self.flag_N in [1, 2]:
pass
elif self.flag_N == 3:
if aline.attrib['N'] < self.N:
self.attrib['N'] = aline.attrib['N']
self.attrib['sig_N'] = aline.attrib['sig_N']
elif aline.attrib['flag_N'] == 0: # No value
warnings.warn("Absline {} has flag=0. Hopefully you expected that")
else:
raise ValueError("Bad flag_N value")
# Enforce 2-element error arrays
if self.attrib['sig_N'].size == 1:
self.attrib['sig_N'] = [self.attrib['sig_N'].value]*2 * self.attrib['sig_N'].unit
# Log values
if self.flag_N > 0:
_, _ = ltaa.log_clm(self.attrib)
def synthesize_colm(self, overwrite=False, redo_aodm=False, **kwargs):
"""Synthesize column density measurements of the component.
Default is to use the current AbsLine values, but the user can
request that those be re-calculated with AODM.
Parameters
----------
overwrite : bool, optional
Clobber any previous measurement
redo_aodm : bool, optional
Redo the individual column density measurements (likely AODM)
Returns
-------
None
Fills the component attributes instead
"""
# Check
if (self.flag_N != 0) and (not overwrite):
raise IOError(
"Column densities already set. Use overwrite=True to redo.")
# Redo?
if redo_aodm:
for aline in self._abslines:
aline.measure_aodm(**kwargs)
# Collate
self.flag_N = 0
for aline in self._abslines:
if aline.attrib['flag_N'] == 0: # No value
warnings.warn(
"Absline {} has flag=0. Hopefully you expected that".
format(str(aline)))
continue
# Check N is filled
if np.allclose(aline.attrib['N'].value, 0.):
raise ValueError(
"Need to set N in attrib. \n Consider linear_clm in linetools.analysis.absline"
)
if aline.attrib['flag_N'] == 1: # Good value?
if self.flag_N == 1: # Weighted mean
# Original
weight = 1. / self.sig_N**2
mu = self.N * weight
# Update
weight += 1. / aline.attrib['sig_N']**2
self.N = (mu + aline.attrib['N'] /
aline.attrib['sig_N']**2) / weight
self.sig_N = np.sqrt(1. / weight)
else: # Fill
self.N = aline.attrib['N']
self.sig_N = aline.attrib['sig_N']
self.flag_N = 1
elif aline.attrib['flag_N'] == 2: # Lower limit
if self.flag_N in [0, 3]:
self.N = aline.attrib['N']
self.sig_N = aline.attrib['sig_N']
self.flag_N = 2
elif self.flag_N == 2:
if aline.attrib['N'] > self.N:
self.N = aline.attrib['N']
self.sig_N = aline.attrib['sig_N']
elif self.flag_N == 1:
pass
elif aline.attrib['flag_N'] == 3: # Upper limit
if self.flag_N == 0:
self.N = aline.attrib['N']
self.sig_N = aline.attrib['sig_N']
self.flag_N = 3
elif self.flag_N in [1, 2]:
pass
elif self.flag_N == 3:
if aline.attrib['N'] < self.N:
self.N = aline.attrib['N']
self.sig_N = aline.attrib['sig_N']
elif aline.attrib['flag_N'] == 0: # No value
warnings.warn(
"Absline {} has flag=0. Hopefully you expected that")
else:
raise ValueError("Bad flag_N value")
# Log values
if self.flag_N > 0:
self.logN, self.sig_logN = ltaa.log_clm(self)
def test_logclm():
obj = type(str('Dummy'), (object, ), {str('N'): 1e13, str('sig_N'): 5e12})
#
logN, sig_logN = log_clm(obj)
np.testing.assert_allclose(logN, 13.)
