def from_dict(cls, idict):
""" Instantiate from a dict. Usually read from the hard-drive
Parameters
----------
idict : dict
Returns
-------
AbsSystem
"""
slf = cls(idict['abs_type'],
SkyCoord(ra=idict['RA']*u.deg, dec=idict['DEC']*u.deg),
idict['zabs'], idict['vlim']*u.km/u.s,
zem=idict['zem'], NHI=idict['NHI'],
sig_NHI=idict['sig_NHI'], name=idict['Name']
)
# Components
components = ltiu.build_components_from_dict(idict)
for component in components:
# This is to insure the components follow the rules
slf.add_component(component)
# Return
return slf
def add_comps_from_dict(slf, idict, skip_components=False, use_coord=False, **kwargs):
"""
Parameters
----------
slf : AbsSystem
skip_components : bool, optional
If True, absorption components (if any exist) are not loaded from the input dict.
Use when you are only interested in the global properties of an AbsSystem
use_coord : bool, optinal
Use coordinates from the AbsSystem to build the components (and lines)
Speeds up performance, but you should know things are OK before using this
Returns
-------
"""
if not skip_components:
# Components
if use_coord: # Speed up performance
coord = slf.coord
else:
coord = None
components = ltiu.build_components_from_dict(idict, coord=coord, **kwargs)
for component in components:
# This is to insure the components follow the rules
slf.add_component(component, **kwargs)
def add_comps_from_dict(slf, idict, skip_components=False, use_coord=False, **kwargs):
"""
Parameters
----------
slf : AbsSystem, AbsSightline
Or any object with an add_component() method
skip_components : bool, optional
If True, absorption components (if any exist) are not loaded from the input dict.
Use when you are only interested in the global properties of an AbsSystem
use_coord : bool, optinal
Use coordinates from the AbsSystem to build the components (and lines)
Speeds up performance, but you should know things are OK before using this
Returns
-------
"""
if not skip_components:
# Components
if use_coord: # Speed up performance
coord = slf.coord
else:
coord = None
components = ltiu.build_components_from_dict(idict, coord=coord, **kwargs)
for component in components:
# This is to insure the components follow the rules
slf.add_component(component, **kwargs)
def components_from_dict(self, abssys_name, coord=None, linelist=None):
""" Build and return a list of AbsComponent objects
from the dict for a given system
Parameters
----------
abssys_name : str
coord : SkyCoord, optional
coordinates to use for the components
linelist : LineList, optional
Returns
-------
compllist : list of AbsComponent objects
"""
# Do it
if linelist is None:
linelist = default_linelist(self.verbose)
# Components
comps = ltiu.build_components_from_dict(self._dict[abssys_name],
coord=coord,
linelist=linelist)
# Return
return comps
def from_dict(cls, idict):
""" Generate an LLSSystem from a dict
Parameters
----------
idict : dict
Usually read from the hard-drive
"""
kwargs = dict(zem=idict['zem'], NHI=idict['NHI'],
sig_NHI=idict['sig_NHI'], name=idict['Name'])
slf = cls(SkyCoord(ra=idict['RA']*u.deg, dec=idict['DEC']*u.deg),
idict['zabs'], idict['vlim']*u.km/u.s, **kwargs)
# Components
components = ltiu.build_components_from_dict(idict)
for component in components:
# This is to insure the components follow the rules
slf.add_component(component)
# Subsystems
if 'A' in idict.keys():
lbls= map(chr, range(65, 91))
for lbl in lbls:
if lbl in idict.keys():
# Generate
subsys = AbsSubSystem.from_dict(slf, idict[lbl], lbl)
slf.subsys[lbl] = subsys
else:
pass
# Total them
slf.nsub = len(slf.subsys.keys())
# Return
return slf
def get_ions(self,
use_Nfile=False,
idict=None,
update_zvlim=True,
linelist=None,
verbose=True):
"""Parse the ions for each Subsystem
And put them together for the full system
Fills ._ionN with a QTable
Parameters
----------
idict : dict, optional
dict containing the IonClms info
use_Nfile : bool, optional
Parse ions from a .clm file (JXP historical)
NOTE: This ignores velocity constraints on components (i.e. skip_vel=True)
update_zvlim : bool, optional
Update zvlim from lines in .clm (as applicable)
linelist : LineList
"""
if use_Nfile:
clm_fil = self.tree + self._datdict['Abund file']
# Read
self._clmdict = igmau.read_clmfile(clm_fil, linelist=linelist)
#pdb.set_trace()
# Build components
components = ltiu.build_components_from_dict(self._clmdict,
coord=self.coord,
chk_vel=False)
# Read .ion file and fill in components
ion_fil = self.tree + self._clmdict['ion_fil']
self._indiv_ionclms = igmau.read_ion_file(ion_fil, components)
# Parse .all file
all_file = ion_fil.split('.ion')[0] + '.all'
self.all_file = all_file #MF: useful
_ = igmau.read_all_file(all_file, components=components)
# Build table
self._ionN = ltiu.iontable_from_components(components,
ztbl=self.zabs)
# Add to AbsSystem
for comp in components:
self.add_component(comp)
elif idict is not None:
table = dict_to_ions(idict)
self._ionN = table
else:
raise IOError("Not ready for this")
def load_components(self, inp):
""" Load components from an input object
Parameters
----------
inp : dict or ??
Input object for loading the components
"""
if isinstance(inp, dict):
components = ltiu.build_components_from_dict(inp, coord=self.coord,
skip_vel=True)
# Add in
for component in components:
self.add_component(component)
else:
raise NotImplementedError("Not ready for this input")
def load_components(self, inp):
""" Load components from an input object
Parameters
----------
inp : dict or ??
Input object for loading the components
"""
if isinstance(inp, dict):
components = ltiu.build_components_from_dict(inp,
coord=self.coord,
skip_vel=True)
# Add in
for component in components:
self.add_component(component)
else:
raise NotImplementedError("Not ready for this input")
def get_ions(self, use_Nfile=False, idict=None, update_zvlim=True,
linelist=None, verbose=True):
"""Parse the ions for each Subsystem
And put them together for the full system
Fills ._ionN with a QTable
Parameters
----------
idict : dict, optional
dict containing the IonClms info
use_Nfile : bool, optional
Parse ions from a .clm file (JXP historical)
NOTE: This ignores velocity constraints on components (i.e. skip_vel=True)
update_zvlim : bool, optional
Update zvlim from lines in .clm (as applicable)
linelist : LineList
"""
if use_Nfile:
clm_fil = self.tree+self._datdict['Abund file']
# Read
self._clmdict = igmau.read_clmfile(clm_fil, linelist=linelist)
#pdb.set_trace()
# Build components
components = ltiu.build_components_from_dict(self._clmdict,
coord=self.coord,
chk_vel=False)
# Read .ion file and fill in components
ion_fil = self.tree+self._clmdict['ion_fil']
self._indiv_ionclms = igmau.read_ion_file(ion_fil, components)
# Parse .all file
all_file = ion_fil.split('.ion')[0]+'.all'
self.all_file=all_file #MF: useful to have
_ = igmau.read_all_file(all_file, components=components)
# Build table
self._ionN = ltiu.iontable_from_components(components, ztbl=self.zabs)
# Add to AbsSystem
for comp in components:
self.add_component(comp)
elif idict is not None:
table = dict_to_ions(idict)
self._ionN = table
else:
raise IOError("Not ready for this")
def from_dict(cls, parent, idict, lbl):
""" Generate a sub-system from a dict
Parameters
----------
parent : AbsSystem
Link
idict : dict
Contains the sub-system parameters
lbl : str
"""
slf = cls(parent, idict['zabs'], idict['vlim'] * u.km / u.s, lbl)
# Components
components = ltiu.build_components_from_dict(idict)
slf._components = components
# Ion table
slf._ionN = ltiu.iontable_from_components(components)
# Return
return slf
def from_dict(cls, parent, idict, lbl):
""" Generate a sub-system from a dict
Parameters
----------
parent : AbsSystem
Link
idict : dict
Contains the sub-system parameters
lbl : str
"""
slf = cls(parent, idict['zabs'], idict['vlim']*u.km/u.s, lbl)
# Components
components = ltiu.build_components_from_dict(idict)
slf._components = components
# Ion table
slf._ionN = ltiu.iontable_from_components(components)
# Return
return slf
def from_dict(cls, idict, skip_components=False, use_coord=False, **kwargs):
""" Instantiate from a dict. Usually read from the hard-drive
Parameters
----------
idict : dict
skip_components : bool, optional
If True, absorption components (if any exist) are not loaded from the input dict.
Use when you are only interested in the global properties of an AbsSystem
use_coord : bool, optinal
Use coordinates from the AbsSystem to build the components (and lines)
Speeds up performance, but you should know things are OK before using this
Returns
-------
AbsSystem
"""
if 'NHI' in idict.keys():
ckwargs = dict(NHI=idict['NHI'], sig_NHI=idict['sig_NHI'], flag_NHI=idict['flag_NHI'])
slf = cls(SkyCoord(ra=idict['RA']*u.deg, dec=idict['DEC']*u.deg),
idict['zabs'], idict['vlim']*u.km/u.s, zem=idict['zem'],
name=idict['Name'], **ckwargs)
# Other
if 'kin' in idict.keys():
slf.kin = ltu.convert_quantity_in_dict(idict['kin'])
if 'Refs' in idict.keys():
slf.Refs = idict['Refs']
# Components
if not skip_components:
# Components
if use_coord: # Speed up performance
coord = slf.coord
else:
coord = None
components = ltiu.build_components_from_dict(idict, coord=coord, **kwargs)
for component in components:
# This is to insure the components follow the rules
slf.add_component(component, **kwargs)
# Return
return slf
def from_dict(cls, idict):
""" Generate a DLASystem from a dict
Parameters
----------
idict : dict
Usually read from the hard-drive
"""
kwargs = dict(zem=idict['zem'], sig_NHI=idict['sig_NHI'],
name=idict['Name'])
slf = cls(SkyCoord(idict['RA'], idict['DEC'], unit='deg'),
idict['zabs'], idict['vlim']*u.km/u.s, idict['NHI'],
**kwargs)
# Components
components = ltiu.build_components_from_dict(idict)
for component in components:
# This is to insure the components follow the rules
slf.add_component(component)
# Return
return slf
def from_dict(cls, idict, **kwargs):
""" Generate a DLASystem from a dict
Parameters
----------
idict : dict
Usually read from the hard-drive
"""
from astropy.coordinates import SkyCoord
kwargs['zem'] = idict['zem']
kwargs['sig_NHI'] = idict['sig_NHI']
kwargs['name'] = idict['Name']
slf = cls(SkyCoord(idict['RA'], idict['DEC'],
unit='deg'), idict['zabs'],
idict['vlim'] * u.km / u.s, idict['NHI'], **kwargs)
# Components
components = ltiu.build_components_from_dict(idict, **kwargs)
for component in components:
# This is to insure the components follow the rules
slf.add_component(component)
# Return
return slf
def load_components(self, inp):
""" Load components for subsystems from an input object
May also update/create subsystems
Parameters
----------
inp : dict or ??
Input object for loading the components
"""
if isinstance(inp, dict):
lbls = map(chr, range(65, 91))
# Subsystems?
if 'A' in inp.keys():
for lbl in lbls:
if lbl in inp.keys():
if lbl not in self.subsys.keys():
self.subsys[lbl] = AbsSubSystem(
self, inp[lbl]['zsys'],
[-300., 300] * u.km / u.s, lbl)
# Fill/update
self.subsys[lbl]._clmdict = inp[
lbl] # Not so necessary
components = ltiu.build_components_from_dict(
self.subsys[lbl]._clmdict,
coord=self.coord,
chk_vel=True)
self.subsys[lbl]._components = components
# Update vlim
self.update_vlim(sub_system=lbl)
else:
pass
self.nsub = len(self.subsys.keys())
else:
raise ValueError("Not sure what to do here")
else:
raise NotImplementedError("Not ready for this input")
def load_components(self, inp):
""" Load components for subsystems from an input object
May also update/create subsystems
Parameters
----------
inp : dict or ??
Input object for loading the components
"""
if isinstance(inp, dict):
lbls= map(chr, range(65, 91))
# Subsystems?
if 'A' in inp.keys():
for lbl in lbls:
if lbl in inp.keys():
if lbl not in self.subsys.keys():
self.subsys[lbl] = AbsSubSystem(self,
inp[lbl]['zsys'],
[-300., 300]*u.km/u.s,
lbl)
# Fill/update
self.subsys[lbl]._clmdict = inp[lbl] # Not so necessary
components = ltiu.build_components_from_dict(self.subsys[lbl]._clmdict,
coord=self.coord,
skip_vel=True)
self.subsys[lbl]._components = components
# Update vlim
self.update_vlim(sub_system=lbl)
else:
pass
self.nsub = len(self.subsys.keys())
else:
raise ValueError("Not sure what to do here")
else:
raise NotImplementedError("Not ready for this input")
def get_ions(self, use_Nfile=False, idict=None, update_zvlim=True, linelist=None):
"""Parse the ions for each Subsystem
And put them together for the full system
Fills ._ionN with a QTable
Parameters
----------
idict : dict, optional
dict containing the IonClms info
use_Nfile : bool, optional
Parse ions from a .clm file (JXP historical)
NOTE: This ignores velocity constraints on components (i.e. skip_vel=True)
update_zvlim : bool, optional
Update zvlim from lines in .clm (as applicable)
linelist : LineList
"""
if idict is not None:
table = dict_to_ions(idict)
self._ionN = table
elif use_Nfile:
# Subsystems
if self.nsub > 0: # This speeds things up (but is rarely used)
linelist = LineList('ISM')
for lbl in self.subsys.keys():
clm_fil = self.tree+self.subsys[lbl]._datdict['clm_file']
# Parse .clm file
self.subsys[lbl]._clmdict = igmau.read_clmfile(clm_fil, linelist=linelist)
# Build components from lines
components = ltiu.build_components_from_dict(self.subsys[lbl]._clmdict,
coord=self.coord, skip_vel=True)
self.subsys[lbl]._components = components
# Update z, vlim
if update_zvlim:
self.update_vlim(sub_system=lbl)
self.subsys[lbl].zabs = self.subsys[lbl]._clmdict['zsys']
# Read .ion file and fill in components
ion_fil = self.tree+self.subsys[lbl]._clmdict['ion_fil']
self.subsys[lbl]._indiv_ionclms = igmau.read_ion_file(ion_fil, components)
# Parse .all file
all_file = ion_fil.split('.ion')[0]+'.all'
self.subsys[lbl].all_file=all_file #MF: useful to have
_ = igmau.read_all_file(all_file, components=components)
# Build table
self.subsys[lbl]._ionN = ltiu.iontable_from_components(components,ztbl=self.subsys[lbl].zabs)
# Add to IGMSystem
for comp in components:
self.add_component(comp)
# Combine
if self.nsub == 1:
self._ionN = self.subsys['A']._ionN
self._clmdict = self.subsys['A']._clmdict
#xdb.set_trace()
elif self.nsub == 0:
raise ValueError('lls_utils.get_ions: Cannot have 0 subsystems..')
else:
self._ionN = self.subsys['A']._ionN
self._clmdict = self.subsys['A']._clmdict
warnings.warn('lls_utils.get_ions: Need to update multiple subsystems!! Taking A.')
else:
raise ValueError("Need an option in get_ions")
def get_ions(self,
use_Nfile=False,
idict=None,
update_zvlim=True,
linelist=None,
verbose=True):
"""Parse the ions for each Subsystem
And put them together for the full system
Fills ._ionN with a QTable
Parameters
----------
idict : dict, optional
dict containing the IonClms info
use_Nfile : bool, optional
Parse ions from a .clm file (JXP historical)
NOTE: This ignores velocity constraints on components (i.e. chk_vel=False)
update_zvlim : bool, optional
Update zvlim from lines in .clm (as applicable)
linelist : LineList
"""
if idict is not None:
table = dict_to_ions(idict)
self._ionN = table
elif use_Nfile:
# Subsystems
if self.nsub > 0: # This speeds things up (but is rarely used)
linelist = LineList('ISM')
for lbl in self.subsys.keys():
clm_fil = self.tree + self.subsys[lbl]._datdict['clm_file']
# Parse .clm file
self.subsys[lbl]._clmdict = igmau.read_clmfile(
clm_fil, linelist=linelist)
# Build components from lines
components = ltiu.build_components_from_dict(
self.subsys[lbl]._clmdict, coord=self.coord, chk_vel=False)
self.subsys[lbl]._components = components
# Update z, vlim
if update_zvlim:
self.update_vlim(sub_system=lbl)
self.subsys[lbl].zabs = self.subsys[lbl]._clmdict['zsys']
# Read .ion file and fill in components
ion_fil = self.tree + self.subsys[lbl]._clmdict['ion_fil']
self.subsys[lbl]._indiv_ionclms = igmau.read_ion_file(
ion_fil, components)
# Parse .all file
all_file = ion_fil.split('.ion')[0] + '.all'
self.subsys[lbl].all_file = all_file #MF: useful to have
_ = igmau.read_all_file(all_file, components=components)
# Build table
self.subsys[lbl]._ionN = ltiu.iontable_from_components(
components, ztbl=self.subsys[lbl].zabs)
# Add to IGMSystem
for comp in components:
self.add_component(comp)
# Combine
if self.nsub == 1:
self._ionN = self.subsys['A']._ionN
self._clmdict = self.subsys['A']._clmdict
#xdb.set_trace()
elif self.nsub == 0:
raise ValueError(
'lls_utils.get_ions: Cannot have 0 subsystems..')
else:
self._ionN = self.subsys['A']._ionN
self._clmdict = self.subsys['A']._clmdict
warnings.warn(
'lls_utils.get_ions: Need to update multiple subsystems!! Taking A.'
)
else:
raise ValueError("Need an option in get_ions")
