def __init__(self, table=None, tooltips=None, name=None, masked=None):
Table.__init__(self, data=table, masked=masked)
self.name = name
# We have to carry internally a raw reference to the
# table data so as to be able to use vstack() to perform
# merging. This shouldn't be a problem as long as the
# LineList instance is regarded as immutable. Which it
# should be anyways.
self._table = table
# each list has associated color, height, and redshift attributes
self.color = None
self.height = DEFAULT_HEIGHT
self.redshift = 0.
self.z_units = 'z'
if len(table[WAVELENGTH_COLUMN].data):
self.wmin = table[WAVELENGTH_COLUMN].data.min()
self.wmax = table[WAVELENGTH_COLUMN].data.max()
else:
self.wmin = self.wmax = None
# A line list (but not the underlying table) can have
# tool tips associated to each column.
self.tooltips = tooltips
def __init__(self, table=None, tooltips=None, name=None, masked=None):
Table.__init__(self, data=table, masked=masked)
self.name = name
# We have to carry internally a raw reference to the
# table data so as to be able to use vstack() to perform
# merging. This shouldn't be a problem as long as the
# LineList instance is regarded as immutable. Which it
# should be anyways.
self._table = table
# each list has associated color, height, and redshift attributes
self.color = None
self.height = DEFAULT_HEIGHT
self.redshift = 0.
self. z_units = 'z'
if len(table[WAVELENGTH_COLUMN].data):
self.wmin = table[WAVELENGTH_COLUMN].data.min()
self.wmax = table[WAVELENGTH_COLUMN].data.max()
else:
self.wmin = self.wmax = None
# A line list (but not the underlying table) can have
# tool tips associated to each column.
self.tooltips = tooltips
def __init__(self, x, y, var=None, names=None, debug=False):
"""
Reads in the data, which can be expressed as y = y(x).
"""
""" Set up the default names """
if names is None:
if var is None:
names = ['x', 'y']
else:
names = ['x', 'y', 'var']
if (debug):
print(names)
print('Length of x vector: %d' % x.size)
print('Length of y vector: %d' % y.size)
""" Link to the inherited class """
if var is None:
Table.__init__(self, [x, y], names=names)
else:
Table.__init__(self, [x, y, var], names=names)
""" Assign simple names to the columns """
self.x = self[self.colnames[0]]
self.y = self[self.colnames[1]]
if var is not None:
self.var = self[self.colnames[2]]
else:
self.var = None
def __init__(self, *args, **kwargs):
"""Initialize the object."""
Table.__init__(self, *args, **kwargs)
self.calibration_coeffs = {}
self.calibration_uncerts = {}
self.calibration = {}
names = [
"Dir", "File", "Scan Type", "Source", "Chan", "Feed", "Time",
"Frequency", "Bandwidth", "Counts", "Counts Err", "Width",
"Width Err", "Flux", "Flux Err", "Elevation", "Azimuth",
"Flux/Counts", "Flux/Counts Err", "Flux Integral/Counts",
"Flux Integral/Counts Err", "Calculated Flux",
"Calculated Flux Err", "RA", "Dec", "Fit RA", "Fit Dec", "RA err",
"Dec err"
]
dtype = [
'S200', 'S200', 'S200', 'S200', 'S200', np.int, np.double,
np.float, np.float, np.float, np.float, np.float, np.float,
np.float, np.float, np.float, np.float, np.float, np.float,
np.float, np.float, np.float, np.float, np.float, np.float,
np.float, np.float, np.float, np.float
]
for n, d in zip(names, dtype):
if n not in self.keys():
self.add_column(Column(name=n, dtype=d))
def __init__(self, target):
self.target = target
tab = Table.read(astrom_data[self.target])
Table.__init__(self, tab)
self['name'] = self['name'].astype('U20')
return
def __init__(self, *args, **kwargs):
"""
Parameters
----------
*args, **kwargs: Same used for astropy tables
"""
APtable.__init__(self, *args, **kwargs)
metakwargs = kwargs['meta'] if 'meta' in kwargs else {}
metawkargs = {} if metakwargs is None else metakwargs
self.meta = GCMetaData(**metakwargs)
def __init__(self, target):
self.target = target
tab = Table.read(astrom_data[self.target])
Table.__init__(self, tab)
self['name'] = self['name'].astype('U20')
self.cut = False # Tracks whether the data has been cut or not
self.time_cut = time_cuts[target]
return
def __init__(self, table=None, name=None, masked=None):
Table.__init__(self, data=table, masked=masked)
self.name = name
# We have to carry internally a raw reference to the
# table data so as to be able to use vstack() to perform
# merging. This shouldn't be a problem as long as the
# LineList instance is regarded as immutable. Which it
# should be anyways.
self._table = table
def _init(self, *args, **kwargs):
"""Line table initializer shared between all LineTable classes."""
names = kwargs.pop('names', None)
assert names is not None
assert len(names) == len(args)
dtype = kwargs.pop('dtype', (np.float,)*len(args))
assert len(dtype) == len(args)
Table.__init__(self,
args + (np.zeros((args[0].size,)),)*3,
names=names+('fit', 'id', 'resid'),
dtype=dtype+(np.float,)*3,
masked=True)
self.meta['class'] = self.__class__.__name__
self.meta['id.mask_value'] = self['id'].fill_value
self.mask['id'] = self.mask['resid'] = True
self.meta['indep'] = names[:-1]
if kwargs:
self.meta.update(kwargs)
def _init(self, *args, **kwargs):
"""Line table initializer shared between all LineTable classes."""
names = kwargs.pop('names', None)
assert names is not None
assert len(names) == len(args)
dtype = kwargs.pop('dtype', (np.float, ) * len(args))
assert len(dtype) == len(args)
Table.__init__(self,
args + (np.zeros((args[0].size, )), ) * 3,
names=names + ('fit', 'id', 'resid'),
dtype=dtype + (np.float, ) * 3,
masked=True)
self.meta['class'] = self.__class__.__name__
self.meta['id.mask_value'] = self['id'].fill_value
self.mask['id'] = self.mask['resid'] = True
self.meta['indep'] = names[:-1]
if kwargs:
self.meta.update(kwargs)
def __init__(self, *args, **kwargs):
Table.__init__(self, *args, **kwargs)
self.sn = None
self.nondetSigmas = 3.
self.groupby = {'filt', 'filter', 'source'}
self.markers = markers.copy()
def __init__(self, *args, **kwargs):
Table.__init__(self, *args, **kwargs)
self.sn = None
def __init__(self, data=None, config_file=None, norefilt=True,
interactive=False, nosave=False, debug=False,
freqsplat=None, nofilt=False, nosub=False, avoid_regions=None,
save_spectrum=False, **kwargs):
"""Load a Scan object
Parameters
----------
data : str or None
data can be one of the following: None, in which case an empty Scan
object is created; a FITS or HDF5 archive, containing an on-the-fly
or cross scan in one of the accepted formats; another `Scan` or
`astropy.Table` object
config_file : str
Config file containing the parameters for the images and the
directories containing the image and calibration data
norefilt : bool
If an HDF5 archive is present with the same basename as the input
FITS file, do not re-run the filtering (default True)
freqsplat : str
See :class:`srttools.scan.interpret_frequency_range`
nofilt : bool
See :class:`srttools.scan.clean_scan_using_variability`
nosub : bool
Do not run the baseline subtraction.
Other Parameters
----------------
kwargs : additional arguments
These will be passed to `astropy.Table` initializer
"""
if config_file is None:
config_file = get_config_file()
if isinstance(data, Table):
Table.__init__(self, data, **kwargs)
elif data is None:
Table.__init__(self, **kwargs)
self.meta['config_file'] = config_file
self.meta.update(read_config(self.meta['config_file']))
else: # if data is a filename
h5name = root_name(data) + '.hdf5'
if os.path.exists(h5name) and norefilt:
# but only if the modification time is later than the
# original file (e.g. the fits file was not modified later)
if os.path.getmtime(h5name) > os.path.getmtime(data):
data = h5name
if debug:
logging.info('Loading file {}'.format(data))
table = read_data(data)
Table.__init__(self, table, masked=True, **kwargs)
if not data.endswith('hdf5'):
self.meta['filename'] = os.path.abspath(data)
self.meta['config_file'] = config_file
self.meta.update(read_config(self.meta['config_file']))
self.check_order()
self.clean_and_splat(freqsplat=freqsplat, nofilt=nofilt,
noise_threshold=self.meta['noise_threshold'],
debug=debug, save_spectrum=save_spectrum)
if interactive:
self.interactive_filter()
if (('backsub' not in self.meta.keys() or
not self.meta['backsub'])) and not nosub:
logging.info('Subtracting the baseline')
self.baseline_subtract(avoid_regions=avoid_regions,
plot=debug)
if not nosave:
self.save()
def __init__(self, masked=None):
Table.__init__(self, names=self.names, dtype=self.dtype, masked=masked)
def __init__(self,
data=None,
norefilt=True,
config_file=None,
freqsplat=None,
nofilt=False,
nosub=False,
**kwargs):
"""Class obtained by a set of scans.
Once the scans are loaded, this class contains all functionality that
will be used to produce (calibrated or uncalibrated) maps with WCS
information.
Parameters
----------
data : str or None
data can be one of the following:
+ a config file, containing the information on the scans to load
+ an HDF5 archive, containing a former scanset
+ another ScanSet or an Astropy Table
config_file : str
Config file containing the parameters for the images and the
directories containing the image and calibration data
norefilt : bool
See :class:`srttools.scan.Scan`
freqsplat : str
See :class:`srttools.scan.interpret_frequency_range`
nofilt : bool
See :class:`srttools.scan.clean_scan_using_variability`
nosub : bool
See :class:`srttools.scan.Scan`
Other Parameters
----------------
kwargs : additional arguments
These will be passed to Scan initializers
Examples
--------
>>> scanset = ScanSet() # An empty scanset
>>> isinstance(scanset, ScanSet)
True
"""
if data is None and config_file is None:
Table.__init__(self, data, **kwargs)
return
self.norefilt = norefilt
self.freqsplat = freqsplat
if isinstance(data, six.string_types) and data.endswith('hdf5'):
data = Table.read(data, path='scanset')
txtfile = data.meta['scan_list_file']
with open(txtfile, 'r') as fobj:
self.scan_list = []
for i in fobj.readlines():
self.scan_list.append(i.strip())
if isinstance(data, Table):
Table.__init__(self, data, **kwargs)
if config_file is not None:
config = read_config(config_file)
self.meta.update(config)
self.create_wcs()
else: # data is a config file
config_file = data
config = read_config(config_file)
self.meta.update(config)
self.meta['config_file'] = config_file
scan_list = \
self.list_scans()
scan_list.sort()
tables = []
for i_s, s in self.load_scans(scan_list,
freqsplat=freqsplat,
nofilt=nofilt,
nosub=nosub,
**kwargs):
if 'FLAG' in s.meta.keys() and s.meta['FLAG']:
continue
s['Scan_id'] = i_s + np.zeros(len(s['time']), dtype=np.long)
ras = s['ra'][:, 0]
decs = s['dec'][:, 0]
ravar = (np.max(ras) - np.min(ras)) / np.cos(np.mean(decs))
decvar = np.max(decs) - np.min(decs)
s['direction'] = np.array(ravar > decvar, dtype=bool)
del s.meta['filename']
del s.meta['calibrator_directories']
del s.meta['list_of_directories']
tables.append(s)
scan_table = Table(vstack(tables))
Table.__init__(self, scan_table)
self.scan_list = scan_list
self.meta['scan_list_file'] = None
self.analyze_coordinates(altaz=False)
self.convert_coordinates()
self.chan_columns = np.array(
[i for i in self.columns if chan_re.match(i)])
self.current = None
def _initfromtable(self, table):
"""Initializer for table, used by classmethod read"""
assert {'x', 'peak'}.issubset(table.columns)
Table.__init__(self, table, masked=True)
self.mask['id'] = self.mask['resid'] = (
self['id'] == self.meta['id.mask_value'])
def _initfromtable(self, table):
"""Initializer for table, used by classmethod read"""
assert {'x', 'peak'}.issubset(table.columns)
Table.__init__(self, table, masked=True)
self.mask['id'] = self.mask['resid'] = (self['id'] ==
self.meta['id.mask_value'])
