def antenna_positions(self, antenna_positions): self._antenna_positions = antenna_positions x = quantity(self.antenna_positions[:, 0], "m") y = quantity(self.antenna_positions[:, 1], "m") z = quantity(self.antenna_positions[:, 2], "m") self._itrf_baselines = self._measures.baseline('itrf', x, y, z) self._up_to_date = False
def earthmagnetic(self, rf='', v0='0G', v1='0..', v2='90..', off=None): """Defines an earthmagnetic measure. It needs a reference code, earthmagnetic quantity values (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given) if the reference code is not for a model, and optionally it can specify an offset, which in itself has to be a earthmagnetic. In general you specify a model (*IGRF* is the default and the only one known) and convert it to an explicit field. (See http://fdd.gsfc.nasa.gov/IGRF.html for information on the International Geomagnetic Reference Field). The earthmagnetic quantity values should be either longitude (angle), latitude(angle) and length(field strength); or x,y,z (field). See :func:`~casacore.quanta.quantity` for possible angle formats. :param rf: reference code string; Allowable reference codes are: *IGRF* :param v0: longitude or x as quantity or string :param v1: latitude or y as quantity or string :param v2: height or z as quantity or string :param off: an optional offset measure of same type """ loc = {'type': "earthmagnetic", 'refer': rf} loc['m0'] = dq.quantity(v0) loc['m1'] = dq.quantity(v1) loc['m2'] = dq.quantity(v2) if is_measure(off): if not off['type'] == "earthmagnetic": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def todoppler(self, rf, v0, rfq): """Convert a radialvelocity measure or a frequency measure to a doppler measure. In the case of a frequency, a rest frequency has to be specified. The type of doppler wanted (e.g. *RADIO*) has to be specified. :param rf: doppler reference code (see :meth:`doppler`) :param v0: a radialvelocity or frequency measure :param rfq: frequency measure or quantity Example:: f = dm.frequency('lsrk','1410MHz') # specify a frequency dm.todoppler('radio', f, dm.constants('HI')) # give doppler, using HI rest """ if is_measure(rfq) and rfq['type'] == 'frequency': rfq = dq.quantity(rfq['m0']) elif isinstance(rfq, str): rfq = dq.quantity(rfq) if is_measure(v0): if v0['type'] == 'radialvelocity': return self.todop(v0, dq.quantity(1., 'Hz')) elif v0['type'] == 'frequency' and dq.is_quantity(rfq) \ and rfq.conforms(dq.quantity('Hz')): return self.todop(v0, rfq) else: raise TypeError('Illegal Doppler or rest frequency specified') else: raise TypeError('Illegal Frequency specified')
def uvw(self, rf='', v0='0..', v1='', v2='', off=None): """Defines a uvw measure. It has to specify a reference code, uvw quantity values (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a uvw. :param rf: reference code string; Allowable reference codes are: *ITRF* and :meth:`direction` codes Note that additional ones may become available. Check with:: dm.list_codes(dm.uvw()) :param v0: longitude or x as quantity or string :param v1: latitude or y as quantity or string :param v2: height or z as quantity or string :param off: an optional offset measure of same type """ loc = {'type': "uvw", 'refer': rf} loc['m0'] = dq.quantity(v0) loc['m1'] = dq.quantity(v1) loc['m2'] = dq.quantity(v2) if is_measure(off): if not off['type'] == "uvw": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def earthmagnetic(self, rf='', v0='0G', v1='0..', v2='90..', off=None): """Defines an earthmagnetic measure. It needs a reference code, earthmagnetic quantity values (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given) if the reference code is not for a model, and optionally it can specify an offset, which in itself has to be a earthmagnetic. In general you specify a model (*IGRF* is the default and the only one known) and convert it to an explicit field. (See http://fdd.gsfc.nasa.gov/IGRF.html for information on the International Geomagnetic Reference Field). The earthmagnetic quantity values should be either longitude (angle), latitude(angle) and length(field strength); or x,y,z (field). See :func:`~casacore.quanta.quantity` for possible angle formats. :param rf: reference code string; Allowable reference codes are: *IGRF* :param v0: longitude or x as quantity or string :param v1: latitude or y as quantity or string :param v2: height or z as quantity or string :param off: an optional offset measure of same type """ loc = {'type': "earthmagnetic", 'refer': rf} loc['m0'] = dq.quantity(v0) loc['m1'] = dq.quantity(v1) loc['m2'] = dq.quantity(v2) if is_measure(off): if not off['type'] == "earthmagnetic": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def tofrequency(self, rf, v0, rfq): """Convert a Doppler type value (e.g. in radio mode) to a frequency. The type of frequency (e.g. LSRK) and a rest frequency (either as a frequency quantity (e.g. ``dm.constants('HI'))`` or a frequency measure (e.g. ``dm.frequency('rest','5100MHz'))`` should be specified. :param rf: frequency reference code (see :meth:`frequency`) :param v0: a doppler measure :param rfq: frequency measure or quantity Example:: dop = dm.doppler('radio',0.4) freq = dm.tofrequency('lsrk', dop, dm.constants('HI')) """ if is_measure(rfq) and rfq['type'] == 'frequency': rfq = dq.quantity(rfq['m0']) elif isinstance(rfq, string_types): rfq = dq.quantity(rfq) if is_measure(v0) and v0['type'] == 'doppler' \ and dq.is_quantity(rfq) \ and rfq.conforms(dq.quantity('Hz')): return self.doptofreq(v0, rf, rfq) else: raise TypeError('Illegal Doppler or rest frequency specified')
def todoppler(self, rf, v0, rfq): """Convert a radialvelocity measure or a frequency measure to a doppler measure. In the case of a frequency, a rest frequency has to be specified. The type of doppler wanted (e.g. *RADIO*) has to be specified. :param rf: doppler reference code (see :meth:`doppler`) :param v0: a radialvelocity or frequency measure :param rfq: frequency measure or quantity Example:: f = dm.frequency('lsrk','1410MHz') # specify a frequency dm.todoppler('radio', f, dm.constants('HI')) # give doppler, using HI rest """ if is_measure(rfq) and rfq['type'] == 'frequency': rfq = dq.quantity(rfq['m0']) elif isinstance(rfq, string_types): rfq = dq.quantity(rfq) if is_measure(v0): if v0['type'] == 'radialvelocity': return self.todop(v0, dq.quantity(1., 'Hz')) elif v0['type'] == 'frequency' and dq.is_quantity(rfq) \ and rfq.conforms(dq.quantity('Hz')): return self.todop(v0, rfq) else: raise TypeError('Illegal Doppler or rest frequency specified') else: raise TypeError('Illegal Frequency specified')
def ITRF_to_J2000(time, x, y, z): dm = cm.measures() dm.do_frame(dm.epoch('UTC', cq.quantity(time, 's'))) ITRF_position = dm.position(rf='ITRF', v0=cq.quantity(x, 'm'), v1=cq.quantity(y, 'm'), v2=cq.quantity(z, 'm')) dm.do_frame(ITRF_position) ITRFLL_position = dm.measure(ITRF_position, 'ITRFLL') height = ITRFLL_position['m2'] ITRFLL_direction = dm.direction('ITRFLL', v0=ITRFLL_position['m0'], v1=ITRFLL_position['m1']) J2000_direction = dm.measure(ITRFLL_direction, 'J2000') J2000_position = dm.position(rf='ITRF', v0=J2000_direction['m0'], v1=J2000_direction['m1'], v2=height) (az, el, r) = (J2000_position['m0']['value'], J2000_position['m1']['value'], J2000_position['m2']['value']) return (az, el, r)
def tofrequency(self, rf, v0, rfq): """Convert a Doppler type value (e.g. in radio mode) to a frequency. The type of frequency (e.g. LSRK) and a rest frequency (either as a frequency quantity (e.g. ``dm.constants('HI'))`` or a frequency measure (e.g. ``dm.frequency('rest','5100MHz'))`` should be specified. :param rf: frequency reference code (see :meth:`frequency`) :param v0: a doppler measure :param rfq: frequency measure or quantity Example:: dop = dm.doppler('radio',0.4) freq = dm.tofrequency('lsrk', dop, dm.constants('HI')) """ if is_measure(rfq) and rfq['type'] == 'frequency': rfq = dq.quantity(rfq['m0']) elif isinstance(rfq, str): rfq = dq.quantity(rfq) if is_measure(v0) and v0['type'] == 'doppler' \ and dq.is_quantity(rfq) \ and rfq.conforms(dq.quantity('Hz')): return self.doptofreq(v0, rf, rfq) else: raise TypeError('Illegal Doppler or rest frequency specified')
def uvw(self, rf='', v0='0..', v1='', v2='', off=None): """Defines a uvw measure. It has to specify a reference code, uvw quantity values (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a uvw. :param rf: reference code string; Allowable reference codes are: *ITRF* and :meth:`direction` codes Note that additional ones may become available. Check with:: dm.list_codes(dm.uvw()) :param v0: longitude or x as quantity or string :param v1: latitude or y as quantity or string :param v2: height or z as quantity or string :param off: an optional offset measure of same type """ loc = {'type': "uvw", 'refer': rf} loc['m0'] = dq.quantity(v0) loc['m1'] = dq.quantity(v1) loc['m2'] = dq.quantity(v2) if is_measure(off): if not off['type'] == "uvw": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def pyTimes2meTimes(pyTimes): obsTimes_lst = [] for obsTime in pyTimes: obsTimes_lst.append(quantity(obsTime.isoformat()).get_value()) obsTimes_me = quantity(obsTimes_lst, 'd') obsTimesArr = obsTimes_me.get_value() obsTimeUnit = obsTimes_me.get_unit() return obsTimesArr, obsTimeUnit
def calculate_separation(skymodel, clusterfile, ra0, dec0, measure): fh = open(skymodel, 'r') fullset = fh.readlines() fh.close() S = {} for cl in fullset: if (not cl.startswith('#')) and len(cl) > 1: cl1 = cl.split() S[cl1[0]] = cl1[1:] fh = open(clusterfile, 'r') fullset = fh.readlines() fh.close() # determine number of clusters ci = 0 for cl in fullset: if (not cl.startswith('#')) and len(cl) > 1: ci += 1 K = ci ra0_q = quantity(ra0, 'rad') dec0_q = quantity(dec0, 'rad') target = measure.direction('j2000', ra0_q, dec0_q) separations = np.zeros(K, dtype=np.float32) azimuths = np.zeros(K, dtype=np.float32) elevations = np.zeros(K, dtype=np.float32) ck = 0 for cl in fullset: if (not cl.startswith('#')) and len(cl) > 1: cl1 = cl.split() for sname in cl1[ 2:3]: # only consider the first source of each cluster # 3:ra 3:dec sI 0 0 0 sP 0 0 0 0 0 0 freq0 sinfo = S[sname] mra = (float(sinfo[0]) + float(sinfo[1]) / 60. + float(sinfo[2]) / 3600.) * 360. / 24. * math.pi / 180.0 mdec = (float(sinfo[3]) + float(sinfo[4]) / 60. + float(sinfo[5]) / 3600.) * math.pi / 180.0 mra_q = quantity(mra, 'rad') mdec_q = quantity(mdec, 'rad') cluster_dir = measure.direction('j2000', mra_q, mdec_q) if ck < K - 1: cluster_dir = measure.direction('j2000', mra_q, mdec_q) else: # last cluster is target cluster_dir = measure.direction('j2000', ra0_q, dec0_q) separation = measure.separation(target, cluster_dir) separations[ck] = separation.get_value() # get elevation of this dir azel = measure.measure(cluster_dir, 'AZEL') azimuths[ck] = azel['m0']['value'] / math.pi * 180 elevations[ck] = azel['m1']['value'] / math.pi * 180 ck += 1 return separations, azimuths, elevations
def __init__(self, obsTimespy): super(PJones, self).__init__() obsTimes_lst = [] for obsTimepy in obsTimespy: obsTimes_lst.append(quantity(obsTimepy.isoformat()).get_value()) obsTimes_me = quantity(obsTimes_lst, 'd') self.obsTimes = obsTimes_me.get_value() self.obsTimeUnit = obsTimes_me.get_unit() self.jonesmeta = {} self.jonesmeta['refFrame'] = 'ITRF'
def __init__(self, obsTimespy, ITRF2stnrot, do_parallactic_rot=True): super(PJones, self).__init__() obsTimes_lst = [] for obsTimepy in obsTimespy: obsTimes_lst.append(quantity(obsTimepy.isoformat()).get_value()) obsTimes_me = quantity(obsTimes_lst, 'd') self.obsTimes = obsTimes_me.get_value() self.obsTimeUnit = obsTimes_me.get_unit() self.ITRF2stnrot = ITRF2stnrot self.do_parallactic_rot = do_parallactic_rot
def convertBasis(me, rbasis, from_refFrame, to_refFrame): basis = np.zeros((3, 3)) for comp in range(3): vr = np.squeeze(rbasis[:, comp]) (az, el) = crt2sph(vr) vr_sph_me = measures().direction(from_refFrame, quantity(az, 'rad'), quantity(el, 'rad')) v_sph_me = me.measure(vr_sph_me, to_refFrame) v_me = sph2crt_me(v_sph_me) basis[:, comp] = v_me return basis
def getBeam(self): """ Return the beam size of the image """ this_pim = pim.image(self.imagename) info_dict = this_pim.info()['imageinfo']['restoringbeam'] # get beam info bpar_ma = quanta.quantity(info_dict['major']).get_value('arcsec') bpar_mi = quanta.quantity(info_dict['minor']).get_value('arcsec') bpar_pa = quanta.quantity(info_dict['positionangle']).get_value('deg') #print('\n{0} - Beam: maj {1:0.3f} (arcsec), min {2:2.3f} (arcsec), pa {3:0.2f} (deg)'.format(img, bpar_ma, bpar_mi,bpar_pa)) return (bpar_ma,bpar_mi,bpar_pa)
def riseset(self, crd, ev="5deg"): """This will give the rise/set times of a source. It needs the position in the frame, and a time. If the latter is not set, the current time will be used. :param crd: a direction measure :param ev: the elevation limit as a quantity or string :returns: The returned value is a `dict` with a 'solved' key, which is `False` if the source is always below or above the horizon. In that case the rise and set fields will all have a string value. The `dict` also returns a rise and set `dict`, with 'last' and 'utc' keys showing the rise and set times as epochs. """ a = self.rise(crd, ev) if isinstance(a['rise'], string_types): return { "rise": { "last": a[0], "utc": a[0] }, "set": { "last": a[1], "utc": a[1] }, "solved": False } ofe = self.measure(self._framestack["epoch"], "utc") if not is_measure(ofe): ofe = self.epoch('utc', 'today') x = a.copy() for k in x: x[k] = self.measure( self.epoch( "last", a[k].totime(), off=self.epoch( "r_utc", (dq.quantity(ofe["m0"]) + dq.quantity("0.5d")))), "utc") return { "rise": { "last": self.epoch("last", a["rise"].totime()), "utc": x["rise"] }, "set": { "last": self.epoch("last", a["set"].totime()), "utc": x["set"] }, "solved": True }
def getParallacticRot(obsTimes, stnPos, srcDir, doPolPrec=True): #Convert python times to pyrap times obsTimes_lst = [] for obsTime in obsTimes: obsTimes_lst.append(quantity(obsTime.isoformat()).get_value()) obsTimes_me = quantity(obsTimes_lst, 'd') print obsTimes_me #Convert source direction to pyrap srcTheta, srcPhi, srcRefFrame = srcDir srcDir = srcRefFrame, str(srcPhi), str(math.pi / 2 - srcTheta) srcDir_me = measures().direction(srcDir[0], srcDir[1] + 'rad', srcDir[2] + 'rad') stnPos_me = measures().position('ITRF', str(stnPos[0, 0]) + 'm', str(stnPos[1, 0]) + 'm', str(stnPos[2, 0]) + 'm') obsTimesArr = obsTimes_me.get_value() obsTimeUnit = obsTimes_me.get_unit() paraMat = np.zeros((len(obsTimesArr), 2, 2)) me = measures() #Set position of reference frame w.r.t. ITRF me.doframe(stnPos_me) if doPolPrec: #Get sky precession rotation matrix #(Assuming no change over data interval) me.doframe(me.epoch('UTC', quantity(obsTimesArr[0], obsTimeUnit))) precMat = getSkyPrecessionMat(me, srcDir_me) for ti in range(len(obsTimesArr)): #Set current time in reference frame timEpoch = me.epoch('UTC', quantity(obsTimesArr[ti], obsTimeUnit)) me.doframe(timEpoch) #Compute polariz comps in spherical sys to cartesian Station coord sys #paraMtc=computeParaMat_tc('J2000', 'ITRF', srcDir_me, me) #Alternatively: paraMme = computeParaMat_me('J2000', 'AZEL', srcDir_me, me) paraM = paraMme if doPolPrec: #With precession: paraM = paraM * precMat #else: #Do not apply precession rotation of polarimetric frame. #This is then the apparent polarization frame. paraMat[ti, :, :] = paraM return paraMat
def expand(self, v): """Calculates the differences between a series of given measure values: it calculates baseline values from position values. :params v: a measure (of type 'baseline', 'position' or 'uvw') :returns: a `dict` with the value for key `measures` being a measure and the value for key `xyz` a quantity containing the differences. Example:: >>> from casacore.quanta import quantity >>> x = quantity([10,50],'m') >>> y = quantity([20,100],'m') >>> z = quantity([30,150],'m') >>> sb = dm.baseline('itrf', x, y, z) >>> out = dm.expand(sb) >>> print out['xyz'] [40.000000000000014, 80.0, 120.0] m """ if not is_measure(v) or v['type'] not in ['baseline', 'position', 'uvw']: raise TypeError("Can only expand baselines, positions, or uvw") vw = v.copy() vw['type'] = "uvw" vw['refer'] = "J2000" outm = _measures.expand(self, vw) outm['xyz'] = dq.quantity(outm['xyz']) outm['measure']['type'] = v['type'] outm['measure']['refer'] = v['refer'] return outm
def frequency(self, rf='', v0='0Hz', off=None): """Defines a frequency measure. It has to specify a reference code, frequency quantity value (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a frequency. :param rf: reference code string; Allowable reference codes are: *REST LSRK LSRD BARY GEO TOPO GALACTO* Note that additional ones may become available. Check with:: dm.list_codes(dm.frequency()) :param v0: frequency value as quantity or string. The frequency quantity values should be in one of the recognised units (examples all give same frequency): * value with time units: a period (0.5s) * value as frequency: 2Hz * value in angular frequency: 720deg/s * value as length: 149896km * value as wave number: 4.19169e-8m-1 * value as enery (h.nu): 8.27134e-9ueV * value as momentum: 4.42044e-42kg.m :param off: an optional offset measure of same type """ loc = {'type': "frequency", 'refer': rf, 'm0': dq.quantity(v0)} if is_measure(off): if not off['type'] == "frequency": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def expand(self, v): """Calculates the differences between a series of given measure values: it calculates baseline values from position values. :params v: a measure (of type 'baseline', 'position' or 'uvw') :returns: a `dict` with the value for key `measures` being a measure and the value for key `xyz` a quantity containing the differences. Example:: >>> from casacore.quanta import quantity >>> x = quantity([10,50],'m') >>> y = quantity([20,100],'m') >>> z = quantity([30,150],'m') >>> sb = dm.baseline('itrf', x, y, z) >>> out = dm.expand(sb) >>> print out['xyz'] [40.000000000000014, 80.0, 120.0] m """ if not is_measure(v) or v['type'] not in ['baseline', 'position', 'uvw']: raise TypeError("Can only expand baselines, positions, or uvw") vw = v.copy() vw['type'] = "uvw" vw['refer'] = "J2000" outm = _measures.expand(self, vw) outm['xyz'] = dq.quantity(outm['xyz']) outm['measure']['type'] = v['type'] outm['measure']['refer'] = v['refer'] return outm
def epoch(self, rf='', v0='0.0d', off=None): """ Defines an epoch measure. It has to specify a reference code, an epoch quantity value (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be an epoch. :param rf: reference code string; Allowable reference codes are: *UTC TAI LAST LMST GMST1 GAST UT1 UT2 TDT TCG TDB TCB* Note that additional ones may become available. Check with:: dm.list_codes(dm.position()) :param v0: time as quantity or string :param off: an optional offset measure of same type """ loc = {'type': 'epoch', 'refer': rf} loc['m0'] = dq.quantity(v0) if is_measure(off): if not off['type'] == "epoch": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def phase_rotate(uvw, times, data, ant1, ant2, obspos, phasecentre, antennas, lambdas): data = data.copy() dm = measures() dm.do_frame(obspos) dm.do_frame(phasecentre) # Recalculate uvw for new phase position new_uvw = np.zeros_like(uvw) # Process visibilities by time so that we calculate antenna baselines # just once for time in set(times): epoch = dm.epoch('UTC', quantity(time, 's')) dm.do_frame(epoch) baselines = dm.as_baseline(antennas) antenna_uvw = np.reshape(dm.to_uvw(baselines)['xyz'].get_value(), (-1, 3)) # Select only those rows for the current time # and update uvw values idx = times == time new_uvw[idx] = antenna_uvw[ant1[idx]] - antenna_uvw[ant2[idx]] # Calculate phase offset woffset = -2j * np.pi * (new_uvw.T[2] - uvw.T[2]) data *= np.exp(woffset[:, np.newaxis] / lambdas)[:, :, np.newaxis] return new_uvw, data
def radialvelocity(self, rf='', v0='0m/s', off=None): """Defines a radialvelocity measure. It has to specify a reference code, radialvelocity quantity value (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a radialvelocity. :param rf: reference code string; Allowable reference codes are: *LSRK LSRD BARY GEO TOPO GALACTO* Note that additional ones may become available. Check with:: dm.list_codes(dm.radialvelocity()) :param v0: longitude or x as quantity or string :param off: an optional offset measure of same type """ loc = {'type': "radialvelocity", 'refer': rf, 'm0': dq.quantity(v0)} if is_measure(off): if not off['type'] == "radialvelocity": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def doppler(self, rf='', v0=0.0, off=None): """Defines a doppler measure. It has to specify a reference code, doppler quantity value (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a doppler. :param rf: reference code string; Allowable reference codes are: *RADIO OPTICAL Z RATIO RELATIVISTIC BETA GAMMA*. Note that additional ones may become available. Check with:: dm.list_codes(dm.doppler()) :param v0: doppler ratio as quantity, string or float value. It should be either non-dimensioned to specify a ratio of the light velocity, or in velocity. (examples all give same doppler): :param off: an optional offset measure of same type Example:: >>> from casacore import quanta >>> dm.doppler('radio', 0.4) >>> dm.doppler('radio', '0.4') >>> dm.doppler('RADIO', quanta.constants['c']*0.4)) """ if isinstance(v0, float): v0 = str(v0) loc = {'type': "doppler", 'refer': rf, 'm0': dq.quantity(v0)} if is_measure(off): if not off['type'] == "doppler": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def radialvelocity(self, rf='', v0='0m/s', off=None): """Defines a radialvelocity measure. It has to specify a reference code, radialvelocity quantity value (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a radialvelocity. :param rf: reference code string; Allowable reference codes are: *LSRK LSRD BARY GEO TOPO GALACTO* Note that additional ones may become available. Check with:: dm.list_codes(dm.radialvelocity()) :param v0: longitude or x as quantity or string :param off: an optional offset measure of same type """ loc = {'type': "radialvelocity", 'refer': rf, 'm0': dq.quantity(v0)} if is_measure(off): if not off['type'] == "radialvelocity": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def epoch(self, rf='', v0='0.0d', off=None): """ Defines an epoch measure. It has to specify a reference code, an epoch quantity value (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be an epoch. :param rf: reference code string; Allowable reference codes are: *UTC TAI LAST LMST GMST1 GAST UT1 UT2 TDT TCG TDB TCB* Note that additional ones may become available. Check with:: dm.list_codes(dm.position()) :param v0: time as quantity or string :param off: an optional offset measure of same type """ loc = {'type': 'epoch', 'refer': rf} loc['m0'] = dq.quantity(v0) if is_measure(off): if not off['type'] == "epoch": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def mjd2datetime(mjd): """ Convert a Modified Julian Date to datetime via 'unix time' representation. NB 'unix time' is defined by the casacore/casacore package. """ q = quantity("%sd" % mjd) return datetime.datetime.fromtimestamp(q.to_unix_time())
def setEpoch(obsTimesArr, obsTimeUnit): stnPos_me = measures().position('ITRF', '0m', '0m', '0m') me = measures() # Set position of reference frame w.r.t. ITRF me.doframe(stnPos_me) timEpoch = me.epoch('UTC', quantity(obsTimesArr, obsTimeUnit)) me.doframe(timEpoch) return me
def mjd2datetime(mjd): """ Convert a Modified Julian Date to datetime via 'unix time' representation. NB 'unix time' is defined by the casacore/casacore package. """ q = quantity("%sd" % mjd) return datetime.datetime.fromtimestamp(q.to_unix_time())
def riseset(self, crd, ev="5deg"): """This will give the rise/set times of a source. It needs the position in the frame, and a time. If the latter is not set, the current time will be used. :param crd: a direction measure :param ev: the elevation limit as a quantity or string :returns: The returned value is a `dict` with a 'solved' key, which is `False` if the source is always below or above the horizon. In that case the rise and set fields will all have a string value. The `dict` also returns a rise and set `dict`, with 'last' and 'utc' keys showing the rise and set times as epochs. """ a = self.rise(crd, ev) if isinstance(a['rise'], str): return {"rise": {"last": a[0], "utc": a[0]}, "set": {"last": a[1], "utc": a[1]}, "solved": False} ofe = self.measure(self._framestack["epoch"], "utc") if not is_measure(ofe): ofe = self.epoch('utc', 'today') x = a.copy() for k in x: x[k] = self.measure( self.epoch("last", a[k].totime(), off=self.epoch("r_utc", (dq.quantity(ofe["m0"]) + dq.quantity("0.5d") )) ), "utc") return {"rise": {"last": self.epoch("last", a["rise"].totime()), "utc": x["rise"]}, "set": {"last": self.epoch("last", a["set"].totime()), "utc": x["set"]}, "solved": True }
def _calculate_uvw(self): uvw_machine = UVW(self.antenna_positions) uvw_machine.set_direction(self.direction) position = measures().position("ITRF", *[quantity(x, "m") for x in self.position]) uvw_machine.set_position(position) self._uvw = np.empty(shape=(self.raw_data.shape[0],self.n_ant,self.n_ant,3), dtype=np.float64) for i,t in enumerate(self.time): uvw_machine.set_time(t.epoch()) self._uvw[i] = uvw_machine() self._uvw_valid = True self._data_valid = False
def set_time(self, value): if is_measure(value): self.set_measure(value) elif isinstance(value, datetime_casacore): self.set_measure(value.epoch()) elif isinstance(value, datetime.datetime): self.set_measure(datetime_casacore.from_datetime(value).epoch()) elif isinstance(value, float): self.set_measure(self._measures.epoch("UTC", quantity(value, "s"))) else: raise TypeError("Unsupported type {} in set_time".format( type(value)))
def rise(self, crd, ev='5deg'): """This method will give the rise/set hour-angles of a source. It needs the position in the frame, and a time. If the latter is not set, the current time will be used. :param crd: a direction measure :param ev: the elevation limit as a quantity or string :returns: `dict` with rise and set sidereal time quantities or a 2 strings "below" or "above" """ if not is_measure(crd): raise TypeError('No rise/set coordinates specified') ps = self._getwhere() self._fillnow() hd = self.measure(crd, "hadec") c = self.measure(crd, "app") evq = dq.quantity(ev) hdm1 = dq.quantity(hd["m1"]) psm1 = dq.quantity(ps["m1"]) ct = (dq.sin(dq.quantity(ev)) - (dq.sin(hdm1) * dq.sin(psm1))) \ / (dq.cos(hdm1) * dq.cos(psm1)) if ct.get_value() >= 1: return {'rise': 'below', 'set': 'below'} if ct.get_value() <= -1: return {'rise': 'above', 'set': 'above'} a = dq.acos(ct) return dict(rise=dq.quantity(c["m0"]).norm(0) - a, set=dq.quantity(c["m0"]).norm(0) + a)
def rise(self, crd, ev='5deg'): """This method will give the rise/set hour-angles of a source. It needs the position in the frame, and a time. If the latter is not set, the current time will be used. :param crd: a direction measure :param ev: the elevation limit as a quantity or string :returns: `dict` with rise and set sidereal time quantities or a 2 strings "below" or "above" """ if not is_measure(crd): raise TypeError('No rise/set coordinates specified') ps = self._getwhere() self._fillnow() hd = self.measure(crd, "hadec") c = self.measure(crd, "app") evq = dq.quantity(ev) hdm1 = dq.quantity(hd["m1"]) psm1 = dq.quantity(ps["m1"]) ct = (dq.sin(dq.quantity(ev)) - (dq.sin(hdm1) * dq.sin(psm1))) \ / (dq.cos(hdm1) * dq.cos(psm1)) if ct.get_value() >= 1: return {'rise': 'below', 'set': 'below'} if ct.get_value() <= -1: return {'rise': 'above', 'set': 'above'} a = dq.acos(ct) return dict(rise=dq.quantity(c["m0"]).norm(0) - a, set=dq.quantity(c["m0"]).norm(0) + a)
def touvw(self, v): """Calculates a uvw measure from a baseline. The baseline can consist of a vector of actual baseline positions. Note that the baseline does not have to be a proper baseline, but can be a series of positions (to call positions baselines see :meth:`asbaseline` ) for speed reasons: operations are linear and can be done on positions, which are converted to baseline values at the end (with :meth:`expand` ). Whatever the reference code of the baseline, the returned uvw will be given in J2000. If the dot argument is given, that variable will be filled with a quantity array consisting of the time derivative of the uvw (note that only the sidereal rate is taken into account; not precession, earth tides and similar variations, which are much smaller). If the xyz variable is given, it will be filled with the quantity values of the uvw measure. The values of the input baselines can be given as a quantity vector per x, y or z value. uvw coordinates are calculated for a certain direction in the sky hence the frame has to contain the direction for the calculation to work. Since the baseline and the sky rotate with respect of each other, the time should be specified as well. Example:: >>> dm.do_frame(dm.observatory('atca')) >>> dm.do_frame(dm.source('1934-638')) >>> dm.do_frame(dm.epoch('utc', 'today')) >>> b = dm.baseline('itrf', '10m', '20m', '30m') """ if is_measure(v) and v['type'] == 'baseline': m = _measures.uvw(self, v) m['xyz'] = dq.quantity(m['xyz']) m['dot'] = dq.quantity(m['dot']) return m else: raise TypeError('Illegal Baseline specified')
def touvw(self, v): """Calculates a uvw measure from a baseline. The baseline can consist of a vector of actual baseline positions. Note that the baseline does not have to be a proper baseline, but can be a series of positions (to call positions baselines see :meth:`asbaseline` ) for speed reasons: operations are linear and can be done on positions, which are converted to baseline values at the end (with :meth:`expand` ). Whatever the reference code of the baseline, the returned uvw will be given in J2000. If the dot argument is given, that variable will be filled with a quantity array consisting of the time derivative of the uvw (note that only the sidereal rate is taken into account; not precession, earth tides and similar variations, which are much smaller). If the xyz variable is given, it will be filled with the quantity values of the uvw measure. The values of the input baselines can be given as a quantity vector per x, y or z value. uvw coordinates are calculated for a certain direction in the sky hence the frame has to contain the direction for the calculation to work. Since the baseline and the sky rotate with respect of each other, the time should be specified as well. Example:: >>> dm.do_frame(dm.observatory('atca')) >>> dm.do_frame(dm.source('1934-638')) >>> dm.do_frame(dm.epoch('utc', 'today')) >>> b = dm.baseline('itrf', '10m', '20m', '30m') """ if is_measure(v) and v['type'] == 'baseline': m = _measures.uvw(self, v) m['xyz'] = dq.quantity(m['xyz']) m['dot'] = dq.quantity(m['dot']) return m else: raise TypeError('Illegal Baseline specified')
def computeJonesRes_overtime(self): """Compute the resulting Jones matrix when the parallactic rotation matrix is applied to a source brightness. The structure is: jones[ti, sphcompIdx, skycompIdx] = paraRot[timeIdx,sphcompIdx,compIdx]*jonesr[compIdx,skycompIdx] """ nrOfTimes = len(self.obsTimes) paraRot = np.zeros((nrOfTimes, 2, 2)) me = measures() me.doframe(measures().position('ITRF', '0m', '0m', '0m')) self.jonesbasis = np.zeros((nrOfTimes, 3, 3)) (az_from, el_from) = crt2sph(self.jonesrbasis[:, 0]) r_sph_me = measures().direction(self.jonesrmeta['refFrame'], quantity(az_from, 'rad'), quantity(el_from, 'rad')) for ti in range(0, nrOfTimes): # Set current time in reference frame timEpoch = me.epoch('UTC', quantity(self.obsTimes[ti], self.obsTimeUnit)) me.doframe(timEpoch) # paraRot[ti,:,:]=computeParaMat_me(self.jonesrmeta['refFrame'], # self.jonesmeta['refFrame'], r_sph_me, me) jonesrbasis_to = np.asmatrix(convertBasis(me, self.jonesrbasis, self.jonesrmeta['refFrame'], self.jonesmeta['refFrame'])) jonesrbasis_to2 = computeSphBasis(self.jonesrmeta['refFrame'], self.jonesmeta['refFrame'], 0, r_sph_me, me) jonesbasisMat = getSph2CartTransf(jonesrbasis_to[:, 0]) #print("to", jonesrbasis_to) paraRot[ti, :, :] = jonesbasisMat[:, 1:].H*jonesrbasis_to[:, 1:] # paraRot[ti,:,:]=jonesrbasis_to2*jonesbasisMat[:,1:] self.jonesbasis[ti, :, :] = jonesbasisMat self.jones = np.matmul(paraRot, self.jonesr) self.thisjones = paraRot
def ITRF2lonlat(x_itrf, y_itrf, z_itrf): """\ Convert ITRF cartesian position coordinates to WGS84 latitude and longitude Parameters ---------- x_itrf: float X coordinate of position in ITRF system in meters. y_itrf: float Y coordinate of position in ITRF system in meters. z_itrf: float Z coordinate of position in ITRF system in meters. Returns ------- lon: float Longitude in degrees lat: float Latitude in degrees hgt: float Height above surface in meters. Examples -------- >>> from ilisa.antennameta.export import ITRF2lonlat >>> ITRF2lonlat(3370286.88256, 712053.913283, 5349991.484) 57.39876274671682, 11.929671631184405, 41.63424105290324 """ dm = measures() posstr = ["{}m".format(crd) for crd in (x_itrf, y_itrf, z_itrf)] p_itrf = dm.position('itrf', *posstr) p_wgs84 = dm.measure(p_itrf, 'wgs84') _ref = dm.get_ref(p_wgs84) lon = quantity(p_wgs84['m0']).get('deg').get_value() lat = quantity(p_wgs84['m1']).get('deg').get_value() hgt = quantity(p_wgs84['m2']).get('m').get_value() return lon, lat, hgt
def position(self, rf='', v0='0..', v1='90..', v2='0m', off=None): """Defines a position measure. It has to specify a reference code, position quantity values (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a position. Note that additional ones may become available. Check with:: dm.list_codes(dm.position()) The position quantity values should be either longitude (angle), latitude(angle) and height(length); or x,y,z (length). See :func:`~casacore.quanta.quantity` for possible angle formats. :param rf: reference code string; Allowable reference codes are: *WGS84* *ITRF* (World Geodetic System and International Terrestrial Reference Frame) :param v0: longitude or x as quantity or string :param v1: latitude or y as quantity or string :param v2: height or z as quantity or string :param off: an optional offset measure of same type Example:: dm.position('wgs84','30deg','40deg','10m') dm.observatory('ATCA') """ loc = {'type': 'position', 'refer': rf} loc['m0'] = dq.quantity(v0) loc['m1'] = dq.quantity(v1) loc['m2'] = dq.quantity(v2) if is_measure(off): if not off['type'] == "position": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def direction(self, rf='', v0='0..', v1='90..', off=None): """Defines a direction measure. It has to specify a reference code, direction quantity values (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a direction. :param rf: reference code string; allowable reference codes are: J2000 JMEAN JTRUE APP B1950 BMEAN BTRUE GALACTIC HADEC AZEL SUPERGAL ECLIPTIC MECLIPTIC TECLIPTIC MERCURY VENUS MARS JUPITER SATURN URANUS NEPTUNE PLUTO MOON SUN COMET. Note that additional ones may become available. Check with:: dm.list_codes(dm.direction()) :param v0, v1: Direction quantity values should be longitude (angle) and latitude (angle) or strings parsable by :func:`~casacore.quanta.quantity`. None are needed for planets: the frame epoch defines coordinates. See :func:`~casacore.quanta.quantity` for possible angle formats. :param off: an optional offset measure of same type Example:: >>> dm.direction('j2000','30deg','40deg') >>> dm.direction('mars') """ loc = {'type': 'direction', 'refer': rf} loc['m0'] = dq.quantity(v0) loc['m1'] = dq.quantity(v1) if is_measure(off): if not off['type'] == "direction": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def CEL2TOPOpnts(obsTimes, stnPos, celPnt): #Convert python times to pyrap times obsTimes_lst = [] for obsTime in obsTimes: obsTimes_lst.append(quantity(obsTime.isoformat()).get_value()) obsTimes_me = quantity(obsTimes_lst, 'd') #Convert source direction to pyrap celPntTheta, celPntPhi, celPntRefFrame = celPnt celPnt = celPntRefFrame, str(celPntPhi), str(math.pi / 2 - celPntTheta) celPnt_me = measures().direction(celPnt[0], celPnt[1] + 'rad', celPnt[2] + 'rad') stnPos_me = measures().position('ITRF', str(stnPos[0, 0]) + 'm', str(stnPos[1, 0]) + 'm', str(stnPos[2, 0]) + 'm') celPntBasis = getSph2CartTransf(sph2crt_me(celPnt_me)) obsTimesArr = obsTimes_me.get_value() obsTimeUnit = obsTimes_me.get_unit() #CelRot=zeros((len(obsTimesArr),2,2)) rotang = np.zeros(len(obsTimesArr)) me = measures() #Set position of reference frame w.r.t. ITRF me.doframe(stnPos_me) me.doframe(me.epoch('UTC', quantity(obsTimesArr[0], obsTimeUnit))) CelRot0 = getRotbetweenRefFrames(celPntRefFrame, 'ITRF', me) rotang[0] = 0.0 for ti in range(1, len(obsTimesArr)): #Set current time in reference frame timEpoch = me.epoch('UTC', quantity(obsTimesArr[ti], obsTimeUnit)) me.doframe(timEpoch) #Incomplete CelRot = getRotbetweenRefFrames(celPntRefFrame, 'ITRF', me) IncRot = CelRot * CelRot0.T rotang[ti] = rotzMat2ang(IncRot) return CelRot0, rotang
def position(self, rf='', v0='0..', v1='90..', v2='0m', off=None): """Defines a position measure. It has to specify a reference code, position quantity values (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a position. Note that additional ones may become available. Check with:: dm.list_codes(dm.position()) The position quantity values should be either longitude (angle), latitude(angle) and height(length); or x,y,z (length). See :func:`~casacore.quanta.quantity` for possible angle formats. :param rf: reference code string; Allowable reference codes are: *WGS84* *ITRF* (World Geodetic System and International Terrestrial Reference Frame) :param v0: longitude or x as quantity or string :param v1: latitude or y as quantity or string :param v2: height or z as quantity or string :param off: an optional offset measure of same type Example:: dm.position('wgs84','30deg','40deg','10m') dm.observatory('ATCA') """ loc = {'type': 'position', 'refer': rf} loc['m0'] = dq.quantity(v0) loc['m1'] = dq.quantity(v1) loc['m2'] = dq.quantity(v2) if is_measure(off): if not off['type'] == "position": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def direction(self, rf='', v0='0..', v1='90..', off=None): """Defines a direction measure. It has to specify a reference code, direction quantity values (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a direction. :param rf: reference code string; allowable reference codes are: J2000 JMEAN JTRUE APP B1950 BMEAN BTRUE GALACTIC HADEC AZEL SUPERGAL ECLIPTIC MECLIPTIC TECLIPTIC MERCURY VENUS MARS JUPITER SATURN URANUS NEPTUNE PLUTO MOON SUN COMET. Note that additional ones may become available. Check with:: dm.list_codes(dm.direction()) :param v0, v1: Direction quantity values should be longitude (angle) and latitude (angle) or strings parsable by :func:`~casacore.quanta.quantity`. None are needed for planets: the frame epoch defines coordinates. See :func:`~casacore.quanta.quantity` for possible angle formats. :param off: an optional offset measure of same type Example:: >>> dm.direction('j2000','30deg','40deg') >>> dm.direction('mars') """ loc = {'type': 'direction', 'refer': rf} loc['m0'] = dq.quantity(v0) loc['m1'] = dq.quantity(v1) if is_measure(off): if not off['type'] == "direction": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def hmstora(rah, ram, ras): """Convert RA in hours, minutes, seconds format to decimal degrees format. Keyword arguments: rah,ram,ras -- RA values (h,m,s) Return value: radegs -- RA in decimal degrees """ sign, rah, ram, ras = propagate_sign(rah, ram, ras) ra = quantity("%s%dH%dM%f" % (sign, rah, ram, ras)).get_value() if abs(ra) >= 360: raise ValueError("coordinates out of range") return ra
def dmstodec(decd, decm, decs): """Convert Dec in degrees, minutes, seconds format to decimal degrees format. Keyword arguments: decd, decm, decs -- list of Dec values (d,m,s) Return value: decdegs -- Dec in decimal degrees """ sign, decd, decm, decs = propagate_sign(decd, decm, decs) dec = quantity("%s%dD%dM%f" % (sign, decd, decm, decs)).get_value() if abs(dec) > 90: raise ValueError("coordinates out of range") return dec
def dmstodec(decd, decm, decs): """Convert Dec in degrees, minutes, seconds format to decimal degrees format. Keyword arguments: decd, decm, decs -- list of Dec values (d,m,s) Return value: decdegs -- Dec in decimal degrees """ sign, decd, decm, decs = propagate_sign(decd, decm, decs) dec = quantity("%s%dD%dM%f" % (sign, decd, decm, decs)).get_value() if abs(dec) > 90: raise ValueError("coordinates out of range") return dec
def getvalue(self, v): """ Return a list of quantities making up the measures' value. :param v: a measure """ if not is_measure(v): raise TypeError('Incorrect input type for getvalue()') import re rx = re.compile("m\d+") out = [] keys = v.keys()[:] keys.sort() for key in keys: if re.match(rx, key): out.append(dq.quantity(v.get(key))) return out
def computeJonesRes_overfield(self): paraRot = np.zeros(self.jonesrbasis.shape[0:-2]+(2, 2)) me = measures() me.doframe(measures().position('ITRF', '0m', '0m', '0m')) self.jonesbasis = np.zeros(self.jonesrbasis.shape) timEpoch = me.epoch('UTC', quantity(self.obsTimes, self.obsTimeUnit)) me.doframe(timEpoch) for idxi in range(self.jonesrbasis.shape[0]): for idxj in range(self.jonesrbasis.shape[1]): jonesrbasis_to = np.asmatrix(convertBasis(me, self.jonesrbasis[idxi, idxj, :, :], self.jonesrmeta['refFrame'], self.jonesmeta['refFrame'])) jonesbasisMat = getSph2CartTransf(jonesrbasis_to[..., 0]) paraRot[idxi, idxj, :, :] = jonesbasisMat[:, 1:].H*jonesrbasis_to[:, 1:] self.jonesbasis[idxi, idxj, :, :] = jonesbasisMat self.jones = np.matmul(paraRot, self.jonesr) self.thisjones = paraRot
def doppler(self, rf='', v0=0.0, off=None): """Defines a doppler measure. It has to specify a reference code, doppler quantity value (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a doppler. :param rf: reference code string; Allowable reference codes are: *RADIO OPTICAL Z RATIO RELATIVISTIC BETA GAMMA*. Note that additional ones may become available. Check with:: dm.list_codes(dm.doppler()) :param v0: doppler ratio as quantity, string or float value. It should be either non-dimensioned to specify a ratio of the light velocity, or in velocity. (examples all give same doppler): :param off: an optional offset measure of same type Example:: >>> from casacore import quanta >>> dm.doppler('radio', 0.4) >>> dm.doppler('radio', '0.4') >>> dm.doppler('RADIO', quanta.constants['c']*0.4)) """ if isinstance(v0, float): v0 = str(v0) loc = {'type': "doppler", 'refer': rf, 'm0': dq.quantity(v0)} if is_measure(off): if not off['type'] == "doppler": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def frequency(self, rf='', v0='0Hz', off=None): """Defines a frequency measure. It has to specify a reference code, frequency quantity value (see introduction for the action on a scalar quantity with either a vector or scalar value, and when a vector of quantities is given), and optionally it can specify an offset, which in itself has to be a frequency. :param rf: reference code string; Allowable reference codes are: *REST LSRK LSRD BARY GEO TOPO GALACTO* Note that additional ones may become available. Check with:: dm.list_codes(dm.frequency()) :param v0: frequency value as quantity or string. The frequency quantity values should be in one of the recognised units (examples all give same frequency): * value with time units: a period (0.5s) * value as frequency: 2Hz * value in angular frequency: 720deg/s * value as length: 149896km * value as wave number: 4.19169e-8m-1 * value as enery (h.nu): 8.27134e-9ueV * value as momentum: 4.42044e-42kg.m :param off: an optional offset measure of same type """ loc = {'type': "frequency", 'refer': rf, 'm0': dq.quantity(v0)} if is_measure(off): if not off['type'] == "frequency": raise TypeError('Illegal offset type specified.') loc["offset"] = off return self.measure(loc, rf)
def format_quantum(self, val, unit): q=quanta.quantity(val,unit) if q.canonical().get_unit() in ['rad','s']: return quanta.quantity(val, 'm').formatted()[:-1]+unit else: return q.formatted()
def main(images, vertices, outfits, maxwidth=0): """ Creates mosaic Parameters ---------- images : str or list of str List of filenames of facet images. May be given as a list or as a string (e.g., '[image1, image2]' vertices : str or list of str List of filenames of facet vertices files. May be given as a list or as a string (e.g., '[vert1, vert2]' outfits : str Filename of output FITS mosaic maxwidth : int, optional Maximum number of pixels to consider for the width of the mosaic [default 0 = unlimited] This can be helpful at high declination. """ if type(images) is str: images = images.strip('[]').split(',') images = [im.strip() for im in images] if type(vertices) is str: vertices = vertices.strip('[]').split(',') vertices = [v.strip() for v in vertices] formstr = '{0:45s} {1:45s} {2:s} {3:s} {4:s} {5:s}' print formstr.format("-----","--------","------------","-------","-------","------") print formstr.format("Image", "FC reg","Norm. weight", "Maj(ac)", "Min(ac)","PA(deg)") print formstr.format("-----","--------","------------","-------","-------","------") psf_fwhm = [] # resolution frequency = [] # frequency of images (should be equal?) for i in range(len(images)): this_pim = pim.image(images[i]) info_dict = this_pim.info()['imageinfo']['restoringbeam'] bpar_ma = quanta.quantity(info_dict['major']).get_value('deg') bpar_mi = quanta.quantity(info_dict['minor']).get_value('deg') bpar_pa = quanta.quantity(info_dict['positionangle']).get_value('deg') psf_fwhm.append([bpar_ma, bpar_mi, bpar_pa]) frequency.append(this_pim.info()['coordinates']['spectral2']['restfreq']) print '{0:45.45s} {1:45.45s} {2:0.2f} {3:0.2f} {4:0.2f} {5:0.2f}'.format(images[i], vertices[i], 0, bpar_ma*60, bpar_mi*60,bpar_pa) psf_fwhm = np.array(psf_fwhm) frequency = np.array(frequency) mean_psf_fwhm = np.mean(psf_fwhm, axis=0) mean_frequency = np.mean(frequency) # Initialize some vectors declims = [] # store the limits of the declination axes raleft = [] raright = [] rainc = [] # store the r.a. increments in case they differ decinc = [] # store the dec increments in case they differ pims = [] # stores the casacore images of the data # Get image frames for input images for im in images: image = pim.image(im) sptcoords = image.coordinates().get_coordinate('spectral') nc = sptcoords.get_axis_size() # Get Stokes axis. Ensure we are working with the Stokes parameter requested. stkcoords = image.coordinates().get_coordinate('stokes') if stkcoords.get_axis_size() == 1: assert(stkcoords.get_stokes()[0] == 'I') else: stks = stkcoords.get_stokes().index('I') image = image.subimage(blc=(0, stks), trc=(nc-1, stks), dropdegenerate=False) ns = 1 dircoords = image.coordinates().get_coordinate('direction') nx = dircoords.get_axis_size(axis=1) ny = dircoords.get_axis_size(axis=0) inc = dircoords.get_increment() ref = dircoords.get_referencepixel() val = dircoords.get_referencevalue() # wsclean image header is weird if val[1]<0: val[1]+=2*np.pi ra_axis = (range(nx)-ref[1])*inc[1]+val[1] dec_axis = (range(ny)-ref[0])*inc[0]+val[0] rainc.append(inc[1]) decinc.append(inc[0]) declims.append(min(dec_axis)) declims.append(max(dec_axis)) mean_ra = np.mean(ra_axis) raleft.append((ra_axis[0]-mean_ra)*np.cos(val[0])+mean_ra) raright.append((ra_axis[-1]-mean_ra)*np.cos(val[0])+mean_ra) pims.append(image) # Generate the mosaic coordinate frame master_dec = np.arange(min(declims),max(declims),min(decinc)) if max(raleft)-min(raright) > 5.*np.pi/3.: # crossed RA=0 for i in range(len(raright)): raright[i] = raright[i]-2.*np.pi master_ra = np.arange(max(raleft),min(raright),max(rainc)) lmra = len(master_ra) if maxwidth != 0: if lmra > maxwidth: xboundary = (lmra-maxwidth)/2 master_ra = master_ra[xboundary:-xboundary] print "Found ra,dec pixel increments (arcsec):" print np.array(rainc)*206265.,np.array(decinc)*206265. ma = pims[-1].coordinates() ma['direction'].set_referencepixel([len(master_dec)/2,len(master_ra)/2]) ma['direction'].set_increment([decinc[np.argmin(np.abs(decinc))],rainc[np.argmin(np.abs(rainc))]]) ma['direction'].set_referencevalue([master_dec[len(master_dec)/2],master_ra[len(master_ra)/2]]) # Initialize the arrays for the output image, sensitivity, and weights master_im = np.zeros((len(master_dec),len(master_ra))) master_mask = np.zeros((len(master_dec),len(master_ra))) # Reproject the images onto the master grid, weight and normalize for i, im in enumerate(pims): print 'doing image',i im, mask = mask_vertices(im, vertices[i]) im = im.regrid([2,3],ma,outshape=(int(nc),int(ns),len(master_dec),len(master_ra))) mask = mask.regrid([2,3],ma,outshape=(int(nc),int(ns),len(master_dec),len(master_ra))) master_im += np.squeeze(im.getdata()) master_mask += np.squeeze(mask.getdata()) blank=np.ones_like(im)*np.nan master_im=np.where(master_mask,master_im,blank) # Write fits files arrax = np.zeros( (1,1, len(master_im[:,0]), len(master_im[0,:])) ) arrax[0,0,:,:] = master_im # Open new casa image for mosaic new_pim = pim.image('',shape=(1,1, len(master_dec),len(master_ra)), coordsys=ma) new_pim.putdata(arrax) # Write fits new_pim.tofits(outfits, overwrite=True) # need to add new beam info (not sure if this is possible with casacore) hdu = pyfits.open(outfits,mode='update') header = hdu[0].header header.update('BMAJ',mean_psf_fwhm[0]) header.update('BMIN',mean_psf_fwhm[1]) header.update('BPA',mean_psf_fwhm[2]) header.update('BUNIT',pims[-1].info()['unit']) header.update('RESTFRQ',mean_frequency) header.update('RESTFREQ',mean_frequency) newhdu = pyfits.PrimaryHDU(data=hdu[0].data, header=header) newhdu.writeto(outfits,clobber=True)
# NB: datetime is not sensitive to leap seconds. # However, leap seconds were first introduced in 1972. # So there are no leap seconds between the start of the # Modified Julian epoch and the start of the Unix epoch, # so this calculation is safe. #julian_epoch = datetime.datetime(1858, 11, 17) #unix_epoch = datetime.datetime(1970, 1, 1, 0, 0) #delta = unix_epoch - julian_epoch #deltaseconds = delta.total_seconds() #unix_epoch = 3506716800 # The above is equivalent to this: unix_epoch = quantity("1970-01-01T00:00:00").get_value('s') def julian2unix(timestamp): """ Convert a modifed julian timestamp (number of seconds since 17 November 1858) to Unix timestamp (number of seconds since 1 January 1970). Args: timestamp (numbers.Number): Number of seconds since the Unix epoch. Returns: numbers.Number: Number of seconds since the modified Julian epoch. """ return timestamp - unix_epoch
def main(msnames, sourcelist="CasA CygA VirA TauA", elevlimit='10deg'): def get_mean_time(ms): obstable = pt.table(ms+'::OBSERVATION', ack=False) meantime = np.mean(obstable.col('TIME_RANGE')[0]) return meantime if msnames[0] == '[': mslist = msnames.lstrip('[').rstrip(']').split(',') for ms in mslist: ms = ms.strip("\'\"") if os.path.isdir(ms): msname = ms break else: msname = msnames print 'gen_demixing_sources.py Using MS:',msname reftime = int(round(get_mean_time(msname))) dm = measures() #position of CS004 dm.doframe(dm.position('ITRF','3.82659e+06m', '460866.m', '5.0649e+06m')) dm.doframe(dm.epoch('utc', qa.quantity(reftime, 's') )) ele_rad = qa.quantity(elevlimit.strip(' []\'\"')).get_value('rad') outstring = "[" sources = [source.strip(' []\'\"') for source in sourcelist.split()] for source in sources: if source == 'CasA': CasA_dir = dm.direction('J2000', '23h23m27.9s','+58d48m42s') azeldir = dm.measure(CasA_dir,'AZEL') if qa.quantity(azeldir['m1']).get_value('rad') > ele_rad : if len(outstring) > 1: outstring +=',' outstring += 'CasA' elif source == 'CygA': CygA_dir = dm.direction('J2000', '19h59m28.3s','+40d44m02s') azeldir = dm.measure(CygA_dir,'AZEL') if qa.quantity(azeldir['m1']).get_value('rad') > ele_rad : if len(outstring) > 1: outstring +=',' outstring += 'CygA' elif source == 'VirA': VirA_dir = dm.direction('J2000', '12h30m49.4233s', '+12d23m28.043s') azeldir = dm.measure(VirA_dir,'AZEL') if qa.quantity(azeldir['m1']).get_value('rad') > ele_rad : if len(outstring) > 1: outstring +=',' outstring += 'VirA' elif source == 'TauA': TauA_dir = dm.direction('J2000', '05h34m32.0s','+22d00m52s') azeldir = dm.measure(TauA_dir,'AZEL') if qa.quantity(azeldir['m1']).get_value('rad') > ele_rad : if len(outstring) > 1: outstring +=',' outstring += 'TauA' elif source == 'HerA': HerA_dir = dm.direction('J2000', '16h51m08.1s','+04d59m33s') azeldir = dm.measure(HerA_dir,'AZEL') if qa.quantity(azeldir['m1']).get_value('rad') > ele_rad : if len(outstring) > 1: outstring +=',' outstring += 'HerA' else: raise ValueError('gen_demixing_sources.py: Unknown Source '+source+'\n' 'Supported sources: CasA, CygA, VirA, TauA, HerA') outstring += "]" outrec = { 'demixsources' : outstring } #outrec['debugout'] = outstring+' ; '+qa.quantity(reftime, 's').formatted('YMD') return outrec
def format_date(self, val, unit): if val==numpy.floor(val): # Do not show time part if 0 return quanta.quantity(val,unit).formatted('YMD_ONLY') else: return quanta.quantity(val,unit).formatted('DMY')
def format_cell(self, val, colkeywords): out="" # String arrays are returned as dict, undo that for printing if isinstance(val, dict): tmpdict=numpy.array(val['array']) tmpdict.reshape(val['shape']) # Leave out quotes around strings numpy.set_printoptions(formatter={'all':lambda x: str(x)}) out+=numpy.array2string(tmpdict, separator=', ') numpy.set_printoptions(formatter=None) else: valtype='other' singleUnit=('QuantumUnits' in colkeywords and (numpy.array(colkeywords['QuantumUnits'])==numpy.array(colkeywords['QuantumUnits'])[0]).all()) if colkeywords.get('MEASINFO',{}).get('type')=='epoch' and singleUnit: # Format a date/time. Use quanta for scalars, use numpy for array logic around it (quanta does not support higher dimensional arrays) valtype='epoch' if isinstance(val, numpy.ndarray): numpy.set_printoptions(formatter={'all':lambda x: self.format_date(x,colkeywords['QuantumUnits'][0])}) out+=numpy.array2string(val,separator=', ') numpy.set_printoptions(formatter=None) else: out+=self.format_date(val,colkeywords['QuantumUnits'][0]) elif colkeywords.get('MEASINFO',{}).get('type')=='direction' and singleUnit and val.shape==(1,2): # Format one direction. TODO: extend to array of directions valtype='direction' out+="[" part=quanta.quantity(val[0,0],'rad').formatted("TIME",precision=9) part=re.sub(r'(\d+):(\d+):(.*)',r'\1h\2m\3',part) out+=part+", " part=quanta.quantity(val[0,1],'rad').formatted("ANGLE",precision=9) part=re.sub(r'(\d+)\.(\d+)\.(.*)',r'\1d\2m\3',part) out+=part+"]" elif isinstance(val, numpy.ndarray) and singleUnit: # Format any array with units valtype='quanta' numpy.set_printoptions(formatter={'all':lambda x: self.format_quantum(x, colkeywords['QuantumUnits'][0])}) out+=numpy.array2string(val,separator=', ') numpy.set_printoptions(formatter=None) elif isinstance(val, numpy.ndarray): valtype='other' # Undo quotes around strings numpy.set_printoptions(formatter={'all':lambda x: str(x)}) out+=numpy.array2string(val,separator=', ') numpy.set_printoptions(formatter=None) elif singleUnit: valtype='onequantum' out+=self.format_quantum(val, colkeywords['QuantumUnits'][0]) else: valtype='other' out+=str(val) if 'QuantumUnits' in colkeywords and valtype=='other': # Print units if they haven't been taken care of if not (numpy.array(colkeywords['QuantumUnits'])==numpy.array(colkeywords['QuantumUnits'])[0]).all(): # Multiple different units for element in an array. TODO: do this properly # For now, just print the units and let the user figure out what it means out+=" "+str(colkeywords['QuantumUnits']) else: out+=" "+colkeywords['QuantumUnits'][0] # Numpy sometimes adds double newlines, don't do that out=out.replace('\n\n','\n') #return valtype+": "+out return out
# Get the azimuth and elevation of Jupiter from Dwingeloo at a given time. # Usage: python azel.py from casacore.measures import measures from casacore.quanta import quantity dm = measures() dm.do_frame(dm.observatory("DWL")) dm.do_frame(dm.epoch("UTC", "2016-06-28 19:54")) # Do the actual conversion of the named direction azeldir = dm.measure(dm.direction("Jupiter"), "AZEL") # Use quanta to convert the returned radians into degrees print quantity(dm.get_value(azeldir)[0]).get("deg") print quantity(dm.get_value(azeldir)[1]).get("deg")