"""

Class used to provide information on MSs

"""

def __init__(self, conf):

self.file_name = conf['file_name']

# save summary info which are often used

ms.open(self.file_name)

self.summary = ms.summary()

self.scansummary = ms.getscansummary()

ms.close()

self.dir_img = self.file_name.replace('.MS','')+'-img/'

# annoying workaround to keep caltables in the same dir of MSs, so plotcal works

self.dir_cal = os.path.dirname(self.file_name)

#self.dir_cal = self.file_name.replace('.MS','')+'-cal/'

self.dir_plot = self.file_name.replace('.MS','')+'-plot/'

self.minBL_for_cal = self.get_minBL_for_cal()

self.nchan = self.get_nchan()

self.freq = self.get_freq()

self.telescope = self.get_telescope()

assert self.telescope == 'GMRT' or self.telescope == 'EVLA'

self.band = self.get_band()

self.spw = conf['spw']

central_nchan = self.nchan*conf['central_chan_percentage']/100.

self.central_chans = str(int(round(self.nchan/2.-central_nchan/2.))) + '~' + str(int(round(self.nchan/2.+central_nchan/2.)))

self.flag = self.set_flag(conf['flag']) # manual flag to be used with flagdata command

self.set_cal_scan_ids(conf['cal_scans']) # sets cal_scan_ids cal_scan_names and cal_scan_unwanted

self.tgt_scan_dict = self.set_tgt_scan_dict(conf['tgt_scans']) # dict of cal scans contining groups of relative cal+tgt scans

if self.telescope == 'GMRT': self.uvrange = '>1000m'

if self.telescope == 'EVLA': self.uvrange = ''

def get_nchan(self):

"""

Return: the number of channels

"""

LocTb = casa.table

LocTb.open(self.file_name+'/SPECTRAL_WINDOW')

nchan = LocTb.getcol('NUM_CHAN')[0]

tb.close()

return nchan

def get_telescope(self):

"""

Return: the telscope name

"""

LocTb = casa.table

LocTb.open(self.file_name+'/OBSERVATION')

telescope = LocTb.getcol('TELESCOPE_NAME')[0]

LocTb.close()

return telescope

def get_band(self):

"""

Return telescope band

"""

if self.telescope == 'GMRT':

if self.freq > 650e6: return '1420'

if self.freq > 600e6 and self.freq < 650e6: return '610'

if self.freq > 300e6 and self.freq < 350e6: return '325'

if self.freq > 200e6 and self.freq < 300e6: return '235'

if self.freq < 200e6: return '151'

elif self.telescope == 'EVLA':

if self.freq < 1e9: return 'P'

if self.freq > 1e9: return 'L'

def get_freq(self):

"""

Return: the reference frequency

"""

LocTb = casa.table

tb.open(self.file_name+'/SPECTRAL_WINDOW')

freq = tb.getcol('REF_FREQUENCY')[0]

tb.close()

LocTb.close()

del LocTb

return freq

def get_antenna_names(self):

"""

Retrun: list of antenna names

"""

LocTb = casa.table

LocTb.open( '%s/ANTENNA' % self.file_name)

antenna_names = LocTb.getcol( 'NAME' )

LocTb.close()

del LocTb

return antenna_names

def get_minBL_for_cal(self):

"""

Return: estimate the minimum BL for calibration steps

"""

num_antenna = len(self.get_antenna_names())

return max(3,int(num_antenna/4.0))

def set_flag(self, flag_string=''):

"""

Convert flag command from the config file to a casa command

e.g.: C14,E03,E04,S01,W01=; =22:30:00~22:43:00; C03=22:52:30~22:55:30

"""

flag = {}

if flag_string != '':

for flag_group in flag_string.replace(' ','').split(';'):

ant = flag_group.split('=')[0]

time = flag_group.split('=')[1]

flag[ant] = time

return flag

def set_cal_scan_ids(self, usr_cal_scan_ids=['']):

"""

Save the calibrator scans in a list

If empy list given, then check for coords

"""

known_cals = {

'3C147':{'m0': {'unit': 'rad', 'value': 1.49488177653836},

'm1': {'unit': 'rad', 'value': 0.87008056907685105},

'refer': 'J2000',

'type': 'direction'},

'3C196':{'m0': {'unit': 'rad', 'value': 2.1537362969610028},

'm1': {'unit': 'rad', 'value': 0.841554132080366},

'refer': 'J2000',

'type': 'direction'},

'3C286':{'m0': {'unit': 'rad', 'value': 3.5392586514514845},

'm1': {'unit': 'rad', 'value': 0.53248541037303654},

'refer': 'J2000',

'type': 'direction'},

'3C295':{'m0': {'unit': 'rad', 'value': 3.7146787856873482},

'm1': {'unit': 'rad', 'value': 0.91111035090915105},

'refer': 'J2000',

'type': 'direction'},

'3C380':{'m0': {'unit': 'rad', 'value': 4.8412379124131713},

'm1': {'unit': 'rad', 'value': 0.85078013643188044},

'refer': 'J2000',

'type': 'direction'},

'3C48':{'m0': {'unit': 'rad', 'value': 0.42624576436309852},

'm1': {'unit': 'rad', 'value': 0.57874633182450852},

'refer': 'J2000',

'type': 'direction'}

}

ms.open(self.file_name)

cal_scan_ids = []

cal_field_ids = []

cal_scan_ids_unwanted = []

for cal_scan_id in self.scansummary.keys():

cal_field_id = self.get_field_id_from_scan_id(cal_scan_id)

dir = ms.getfielddirmeas(fieldid=int(cal_field_id))

# if distance with known cal is < than 60" then add it

for known_cal, known_cal_dir in known_cals.iteritems():

if au.angularSeparationOfDirectionsArcsec(dir, known_cal_dir) <= 60:

if cal_scan_id not in usr_cal_scan_ids and usr_cal_scan_ids != ['']:

# user do not want this scan

logging.info('Found '+known_cal+' in scan: '+cal_scan_id+' *** Ignored')

cal_scan_ids_unwanted.append(cal_scan_id)

else:

logging.info('Found '+known_cal+' in scan: '+cal_scan_id)

cal_scan_ids.append(cal_scan_id)

cal_field_ids.append(str(cal_field_id))

# update field name for SetJy

tb.open('%s/FIELD' % self.file_name, nomodify=False)

tb.putcell('NAME', int(cal_field_id), known_cal)

source_id = tb.getcell('SOURCE_ID', int(cal_field_id))

tb.close()

tb.open('%s/SOURCE' % self.file_name, nomodify=False)

tb.putcell('NAME', source_id, known_cal)

tb.close()

break # cal found, useless to keep on iterating

ms.close()

if cal_scan_ids == []:

logging.critical('No calibrators found')

sys.exit(1)

self.cal_scan_ids = cal_scan_ids

self.cal_field_ids = list(set(cal_field_ids))

self.cal_scan_ids_unwanted = cal_scan_ids_unwanted

def set_tgt_scan_dict(self, usr_tgt_scan_ids=['']):

"""

Set the target scans in a dict associating each calibrator to the closest in time {cal1:[tgt1,tgt2],cal2:[tgt3]}

if tgt_scans is given, then restrict to those scans

"""

# getting calibrators central time

cal_times = {}

for cal_scan_id in self.cal_scan_ids:

begin = self.scansummary[cal_scan_id]['0']['BeginTime']

end = self.scansummary[cal_scan_id]['0']['EndTime']

cal_times[cal_scan_id] = begin+(end-begin)/2.

# finding the closest cal in time for each target

tgt_scans_dict = {}

for tgt_scan_id, tgt_scan_data in self.scansummary.iteritems():

if tgt_scan_id not in usr_tgt_scan_ids and usr_tgt_scan_ids != ['']: continue # user do not want this scan

if tgt_scan_id in self.cal_scan_ids_unwanted: continue # it's a discarded calibrator

if tgt_scan_id in self.cal_scan_ids: continue # cal scan, not a tgt scan

begin = tgt_scan_data['0']['BeginTime']

end = tgt_scan_data['0']['EndTime']

tgt_time = begin+(end-begin)/2.

min_time = np.inf

for cal_scan_id, cal_time in cal_times.iteritems():

if abs(cal_time - tgt_time) < abs(min_time - tgt_time):

min_time = cal_time

min_cal = cal_scan_id

# add the calibrator to the dict tgt_scans_dict

if not min_cal in tgt_scans_dict: tgt_scans_dict[min_cal] = [min_cal]

tgt_scans_dict[min_cal].append(tgt_scan_id)

# printing the results

for cal_scan_id in tgt_scans_dict:

logging.info('Calibrator '+cal_scan_id+' ('+self.get_field_name_from_scan_id(cal_scan_id)+'):')

for tgt_scan_id in tgt_scans_dict[cal_scan_id]:

logging.info('\t * '+tgt_scan_id+' ('+self.get_field_name_from_scan_id(tgt_scan_id)+') ')

return tgt_scans_dict

def get_field_name_from_field_id(self, field):

"""

Return: the source name associated with a given field id

"""

field_name = self.summary['field_'+str(field)]['name']

return field_name

def get_field_name_from_scan_id(self, scan):

"""

Return: the source name associated with a given scan id

"""

field_name = self.summary['scan_'+str(scan)]['0']['FieldName']

return field_name

def get_field_id_from_scan_id(self, scan):

"""

Return: the field id associated with a given scan id

"""

field_id = self.summary['scan_'+str(scan)]['0']['FieldId']

"""

Print (and return) the falg statistics

"""

from casa import agentflagger as af

af.open(ms)

af.selectdata(field=field, spw=spw)

agentSummary={'mode':'summary'}

af.parseagentparameters(agentSummary)

af.init()

summary = af.run()

af.done()

del af

array_flag = summary['report0']['array']['0']

logging.info("Flag percentage: " + str(array_flag['flagged']/array_flag['total']*100.) + "%")

# ------------------------------------------------------------------------------

# RefAntHeuristics::__init__

# Description:

# ------------

# This public member function constructs an instance of the RefAntHeuristics()

# class.

# NB: If all of the defaults are chosen, no reference antenna list is returned.

# Inputs:

# -------

# vis - This python string contains the MS name.

#

# field - This python string or list of strings contains the field numbers

# or IDs. Presently it is used only for the flagging heuristic.

# The default is ''.

# spw - This python string or list of strings contains the spectral

# window numbers of IDs. Presently it is used only for the

# flagging heuristic. The default is ''.

# intent - This python string or list of strings contains the intent(s).

# Presently it is used only for the flagging heuristic. The

# default is ''.

#

# geometry - This python boolean determines whether the geometry heuristic

# will be used in automatic mode. The default is False.

# flagging - This python boolean determines whether the flagging heuristic

# will be used in automatic mode. The default is False.

# Outputs:

# --------

# None, returned via the function value.

# Modification history:

# ---------------------

# 2012 May 21 - Nick Elias, NRAO

# Initial version.

# 2012 Jun 06 - Nick Eluas, NRAO

# Input parameter defaults added.

# ------------------------------------------------------------------------------

def __init__(

self,

vis,

field='',

spw='',

intent='',

geometry=False,

flagging=False,

):

# Initialize the public member variables of this class

self.vis = vis

self.field = field

self.spw = spw

self.intent = intent

self.geometry = geometry

self.flagging = flagging

# Return None

return None

# ------------------------------------------------------------------------------

# RefAntHeuristics::calculate

# Description:

# ------------

# This public member function forms the reference antenna list calculated from

# the selected heuristics.

# NB: A total score is calculated from all heuristics. The best antennas have

# the highest scores, so a reverse sort is performed to obtain the final list.

# Inputs:

# -------

# None.

# Outputs:

# --------

# The np array of strings containing the ranked reference antenna list,

# returned via the function value.

# Modification history:

# ---------------------

# 2012 May 21 - Nick Elias, NRAO

# Initial version.

# ------------------------------------------------------------------------------

def calculate(self):

# If no heuristics are specified, return no reference antennas

if not (self.geometry or self.flagging):

return []

# Get the antenna names and initialize the score dictionary

names = self._get_names()

score = dict()

for n in names:

score[n] = 0.0

# For each selected heuristic, add the score for each antenna

self.geoScore = 0.0

self.flagScore = 0.0

if self.geometry:

geoClass = RefAntGeometry(self.vis)

self.geoScore = geoClass.calc_score()

for n in names:

score[n] += self.geoScore[n]

if self.flagging:

flagClass = RefAntFlagging(self.vis, self.field, self.spw,

self.intent)

self.flagScore = flagClass.calc_score()

for n in names:

try:

score[n] += self.flagScore[n]

except KeyError, e:

logging.warning('Antenna ' + str(e) + ', is completely flagged and missing')

# Calculate the final score and return the list of ranked

# reference antennas. NB: The best antennas have the highest

# score, so a reverse sort is required.

keys = np.array(score.keys())

values = np.array(score.values())

argSort = np.argsort(values)[::-1]

refAnt = keys[argSort]

return refAnt

# ------------------------------------------------------------------------------

# RefAntHeuristics::_get_names

# Description:

# ------------

# This private member function gets the antenna names from the MS.

# Inputs:

# -------

# None.

# Outputs:

# --------

# The np array of strings containing the antenna names, returned via the

# function value.

# Modification history:

# ---------------------

# 2012 May 21 - Nick Elias, NRAO

# Initial version.

# ------------------------------------------------------------------------------

def _get_names(self):

tb.open(self.vis + '/ANTENNA')

names = tb.getcol('NAME').tolist()

tb.close()

# ------------------------------------------------------------------------------

# RefAntGeometry::__init__

# Description:

# ------------

# This public member function constructs an instance of the RefAntGeometry()

# class.

# Inputs:

# -------

# vis - This python string contains the MS name.

# Outputs:

# --------

# None, returned via the function value.

# Modification history:

# ---------------------

# 2012 May 21 - Nick Elias, NRAO

# Initial version.

# ------------------------------------------------------------------------------

def __init__(self, vis):

# Set the public variables

self.vis = vis

# Return None

return None

# ------------------------------------------------------------------------------

# RefAntGeometry::calc_score

# Description:

# ------------

# This public member function calculates the geometry score for each antenna.

# Inputs:

# -------

# None.

# Outputs:

# --------

# The python dictionary containing the score for each antenna, returned via the

# function value.

# Modification history:

# ---------------------

# 2012 May 21 - Nick Elias, NRAO

# Initial version.

# ------------------------------------------------------------------------------

def calc_score(self):

# Get the antenna information, measures, and locations

info = self._get_info()

measures = self._get_measures(info)

(radii, longs, lats) = self._get_latlongrad(info, measures)

# Calculate the antenna distances and scores

distance = self._calc_distance(radii, longs, lats)

score = self._calc_score(distance)

# Return the scores

return score

# ------------------------------------------------------------------------------

# RefAntGeometry::_get_info

# Description:

# ------------

# This private member function gets the information from the antenna table of

# the MS.

# Inputs:

# -------

# None.

# Outputs:

# --------

# The python dictionary containing the antenna information, returned via the

# function value. The dictionary format is:

# 'position' - This np array contains the antenna positions.

# 'flag_row' - This np array of booleans contains the flag row

# booleans. NB: This element is of limited use now and

# may be eliminated.

# 'name' - This np array of strings contains the antenna names.

# 'position_keywords' - This python dictionary contains the antenna information.

# Modification history:

# ---------------------

# 2012 May 21 - Nick Elias, NRAO

# Initial version.

# ------------------------------------------------------------------------------

def _get_info(self):

tb.open(self.vis + '/ANTENNA')

# Get the antenna information from the antenna table

info = dict()

info['position'] = tb.getcol('POSITION')

info['flag_row'] = tb.getcol('FLAG_ROW')

info['name'] = tb.getcol('NAME')

info['position_keywords'] = tb.getcolkeywords('POSITION')

tb.close()

# Return the antenna information

return info

# ------------------------------------------------------------------------------

# RefAntGeometry::_get_measures

# Description:

# ------------

# This private member function gets the measures from the antenna table of the

# MS.

# Inputs:

# -------

# info - This python dictionary contains the antenna information from private

# member function _get_info().

# Outputs:

# --------

# The python dictionary containing the antenna measures, returned via the

# function value. The dictionary format is:

# '<antenna name>' - The python dictionary containing the antenna measures.

# Modification history:

# ---------------------

# 2012 May 21 - Nick Elias, NRAO

# Initial version.

# ------------------------------------------------------------------------------

def _get_measures(self, info):

# Initialize the measures dictionary and the position and

# position_keywords variables

measures = dict()

position = info['position']

position_keywords = info['position_keywords']

rf = position_keywords['MEASINFO']['Ref']

for (row, ant) in enumerate(info['name']):

if not info['flag_row'][row]:

p = position[0, row]

pk = position_keywords['QuantumUnits'][0]

v0 = qa.quantity(p, pk)

p = position[1, row]

pk = position_keywords['QuantumUnits'][1]

v1 = qa.quantity(p, pk)

p = position[2, row]

pk = position_keywords['QuantumUnits'][2]

v2 = qa.quantity(p, pk)

measures[ant] = me.position(rf=rf, v0=v0, v1=v1,

v2=v2)

# Return the measures

return measures

# ------------------------------------------------------------------------------

# RefAntGeometry::_get_latlongrad

# Description:

# ------------

# This private member function gets the latitude, longitude and radius (from the

# center of the earth) for each antenna.

# Inputs:

# -------

# info - This python dictionary contains the antenna information from

# private member function _get_info().

# measures - This python dictionary contains the antenna measures from private

# member function _get_measures().

# Outputs:

# --------

# The python tuple containing containing radius, longitude, and latitude python

# dictionaries, returned via the function value.

# Modification history:

# ---------------------

# 2012 May 21 - Nick Elias, NRAO

# Initial version.

# ------------------------------------------------------------------------------

def _get_latlongrad(self, info, measures):

# Get the radii, longitudes, and latitudes

radii = dict()

longs = dict()

lats = dict()

for ant in info['name']:

value = measures[ant]['m2']['value']

unit = measures[ant]['m2']['unit']

quantity = qa.quantity(value, unit)

convert = qa.convert(quantity, 'm')

radii[ant] = qa.getvalue(convert)

value = measures[ant]['m0']['value']

unit = measures[ant]['m0']['unit']

quantity = qa.quantity(value, unit)

convert = qa.convert(quantity, 'rad')

longs[ant] = qa.getvalue(convert)

value = measures[ant]['m1']['value']

unit = measures[ant]['m1']['unit']

quantity = qa.quantity(value, unit)

convert = qa.convert(quantity, 'rad')

lats[ant] = qa.getvalue(convert)

# Return the tuple containing the radius, longitude, and

# latitude python dictionaries

return (radii, longs, lats)

# ------------------------------------------------------------------------------

# RefAntGeometry::_calc_distance

# Description:

# ------------

# This private member function calculates the antenna distances from the array

# reference from the radii, longitudes, and latitudes.

# NB: The array reference is the median location.

# Inputs:

# -------

# radii - This python dictionary contains the radius (from the center of the

# earth) for each antenna.

# longs - This python dictionary contains the longitude for each antenna.

# lats - This python dictionary contains the latitude for each antenna.

# Outputs:

# --------

# The python dictionary containing the antenna distances from the array

# reference, returned via the function value.

# Modification history:

# ---------------------

# 2012 May 21 - Nick Elias, NRAO

# Initial version.

# ------------------------------------------------------------------------------

def _calc_distance(

self,

radii,

longs,

lats,

):

# Convert the dictionaries to np float arrays. The median

# longitude is subtracted.

radiusValues = np.array(radii.values())

longValues = np.array(longs.values())

longValues -= np.median(longValues)

latValues = np.array(lats.values())

# Calculate the x and y antenna locations. The medians are

# subtracted.

x = longValues * np.cos(latValues) * radiusValues

x -= np.median(x)

y = latValues * radiusValues

y -= np.median(y)

# Calculate the antenna distances from the array reference and

# return them

distance = dict()

names = radii.keys()

for (i, ant) in enumerate(names):

distance[ant] = np.sqrt(pow(x[i], 2) + pow(y[i], 2))

return distance

# ------------------------------------------------------------------------------

# RefAntGeometry::_calc_score

# Description:

# ------------

# This private member function calculates the geometry score for each antenna.

# Algorithm:

# ----------

# * Calculate the antenna distances from the array center.

# * Normalize the distances by the maximum distance.

# * Calculate the score for each antenna, which is one minus the normalized

# distance. The best antennas have the highest score.

# * Sort according to score.

# Inputs:

# -------

# distance - This python dictionary contains the antenna distances from the

# array reference. They are calculated in private member function

# _calc_distance().

# Outputs:

# --------

# The python dictionary containing the score for each antenna, returned via the

# function value.

# Modification history:

# ---------------------

# 2012 May 21 - Nick Elias, NRAO

# Initial version.

# ------------------------------------------------------------------------------

def _calc_score(self, distance):

# Get the number of good data, calculate the fraction of good

# data, and calculate the good and bad weights

far = np.array(distance.values(), np.float)

fFar = far / float(np.max(far))

wFar = fFar * len(far)

wClose = (1.0 - fFar) * len(far)

# Calculate the score for each antenna and return them

score = dict()

names = distance.keys()

rName = range(len(wClose))

for n in rName:

score[names[n]] = wClose[n]