source: trunk/python/asapmath.py@ 462

Last change on this file since 462 was 458, checked in by kil064, 20 years ago

move scantable.rotate_xyphase to asapmath.py

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 16.8 KB
RevLine 
[101]1from scantable import scantable
[258]2from asap import rcParams
[101]3
[143]4def average_time(*args, **kwargs):
[101]5 """
[113]6 Return the (time) average of a scan or list of scans. [in channels only]
[305]7 The cursor of the output scan is set to 0
[113]8 Parameters:
9 one scan or comma separated scans
[143]10 mask: an optional mask (only used for 'var' and 'tsys' weighting)
[424]11 scanav: True (default) averages each scan separately
12 False averages all scans together,
[143]13 weight: Weighting scheme. 'none' (default), 'var' (variance
14 weighted), 'tsys'
[113]15 Example:
16 # return a time averaged scan from scana and scanb
17 # without using a mask
[129]18 scanav = average_time(scana,scanb)
[113]19 # return the (time) averaged scan, i.e. the average of
20 # all correlator cycles
21 scanav = average_time(scan)
[143]22
[101]23 """
[424]24 scanAv = True
[143]25 if kwargs.has_key('scanav'):
26 scanAv = kwargs.get('scanav')
27 weight = 'none'
28 if kwargs.has_key('weight'):
29 weight = kwargs.get('weight')
30 mask = ()
31 if kwargs.has_key('mask'):
32 mask = kwargs.get('mask')
33 lst = tuple(args)
34 from asap._asap import average as _av
[113]35 for s in lst:
[101]36 if not isinstance(s,scantable):
37 print "Please give a list of scantables"
38 return
[143]39 return scantable(_av(lst, mask, scanAv, weight))
[101]40
[245]41def quotient(source, reference, preserve=True):
[101]42 """
[246]43 Return the quotient of a 'source' (signal) scan and a 'reference' scan.
44 The reference can have just one row, even if the signal has many. Otherwise
45 they must have the same number of rows.
[305]46 The cursor of the output scan is set to 0
[101]47 Parameters:
48 source: the 'on' scan
49 reference: the 'off' scan
[245]50 preserve: you can preserve (default) the continuum or
51 remove it. The equations used are
52 preserve - Output = Tref * (sig/ref) - Tref
53 remove - Output = Tref * (sig/ref) - Tsig
[101]54 """
55 from asap._asap import quotient as _quot
[245]56 return scantable(_quot(source, reference, preserve))
[101]57
[296]58def simple_math(left, right, op='add', tsys=True):
[242]59 """
60 Apply simple mathematical binary operations to two
61 scan tables, returning the result in a new scan table.
62 The operation is applied to both the correlations and the TSys data
[305]63 The cursor of the output scan is set to 0
[242]64 Parameters:
65 left: the 'left' scan
66 right: the 'right' scan
67 op: the operation: 'add' (default), 'sub', 'mul', 'div'
[296]68 tsys: if True (default) then apply the operation to Tsys
69 as well as the data
[242]70 """
[258]71 if not isinstance(left,scantable) and not isinstance(right,scantable):
72 print "Please provide two scantables as input"
73 return
[242]74 from asap._asap import b_operate as _bop
[296]75 return scantable(_bop(left, right, op, tsys))
[242]76
[296]77def scale(scan, factor, insitu=None, allaxes=None, tsys=True):
[101]78 """
79 Return a scan where all spectra are scaled by the give 'factor'
80 Parameters:
81 scan: a scantable
[113]82 factor: the scaling factor
[258]83 insitu: if False a new scantable is returned.
[150]84 Otherwise, the scaling is done in-situ
[258]85 The default is taken from .asaprc (False)
86 allaxes: if True apply to all spectra. Otherwise
87 apply only to the selected (beam/pol/if)spectra only.
[435]88 The default is taken from .asaprc (True if none)
[296]89 tsys: if True (default) then apply the operation to Tsys
90 as well as the data
[101]91 """
[258]92 if allaxes is None: allaxes = rcParams['scantable.allaxes']
93 if insitu is None: insitu = rcParams['insitu']
[141]94 if not insitu:
95 from asap._asap import scale as _scale
[296]96 return scantable(_scale(scan, factor, allaxes, tsys))
[141]97 else:
98 from asap._asap import scale_insitu as _scale
[296]99 _scale(scan, factor, allaxes, tsys)
[141]100 return
101
[101]102
[258]103def add(scan, offset, insitu=None, allaxes=None):
[113]104 """
[150]105 Return a scan where all spectra have the offset added
[113]106 Parameters:
107 scan: a scantable
[150]108 offset: the offset
[258]109 insitu: if False a new scantable is returned.
110 Otherwise, the scaling is done in-situ
111 The default is taken from .asaprc (False)
112 allaxes: if True apply to all spectra. Otherwise
[150]113 apply only to the selected (beam/pol/if)spectra only
[435]114 The default is taken from .asaprc (True if none)
[113]115 """
[258]116 if allaxes is None: allaxes = rcParams['scantable.allaxes']
117 if insitu is None: insitu = rcParams['insitu']
[150]118 if not insitu:
119 from asap._asap import add as _add
[258]120 return scantable(_add(scan, offset, allaxes))
[150]121 else:
122 from asap._asap import add_insitu as _add
[258]123 _add(scan, offset, allaxes)
[150]124 return
125
[359]126def convert_flux(scan, jyperk=None, eta=None, d=None, insitu=None, allaxes=None):
[224]127 """
128 Return a scan where all spectra are converted to either Jansky or Kelvin
[359]129 depending upon the flux units of the scan table. By default the
130 function tries to look the values up internally. If it can't find
131 them (or if you want to over-ride), you must specify EITHER jyperk
132 OR eta (and D which it will try to look up also if you don't
133 set it). jyperk takes precedence if you set both.
[224]134 Parameters:
135 scan: a scantable
[359]136 jyperk: the Jy / K conversion factor
137 eta: the aperture efficiency
138 d: the geomtric diameter (metres)
[258]139 insitu: if False a new scantable is returned.
140 Otherwise, the scaling is done in-situ
141 The default is taken from .asaprc (False)
142 allaxes: if True apply to all spectra. Otherwise
[224]143 apply only to the selected (beam/pol/if)spectra only
[435]144 The default is taken from .asaprc (True if none)
[224]145 """
[258]146 if allaxes is None: allaxes = rcParams['scantable.allaxes']
147 if insitu is None: insitu = rcParams['insitu']
[359]148 if jyperk is None: jyperk = -1.0
149 if d is None: d = -1.0
150 if eta is None: eta = -1.0
[224]151 if not insitu:
152 from asap._asap import convertflux as _convert
[359]153 return scantable(_convert(scan, d, eta, jyperk, allaxes))
[224]154 else:
155 from asap._asap import convertflux_insitu as _convert
[359]156 _convert(scan, d, eta, jyperk, allaxes)
[224]157 return
[229]158
[411]159def gain_el(scan, poly=None, filename="", method="linear",
160 insitu=None, allaxes=None):
[229]161 """
[242]162 Return a scan after applying a gain-elevation correction. The correction
163 can be made via either a polynomial or a table-based interpolation
164 (and extrapolation if necessary).
165 You specify polynomial coefficients, an ascii table or neither.
166 If you specify neither, then a polynomial correction will be made
167 with built in coefficients known for certain telescopes (an error will
168 occur if the instrument is not known).
[229]169 Parameters:
170 scan: a scantable
[258]171 poly: Polynomial coefficients (default None) to compute a
172 gain-elevation correction as a function of
173 elevation (in degrees).
[242]174 filename: The name of an ascii file holding correction factors.
175 The first row of the ascii file must give the column
176 names and these MUST include columns
[258]177 "ELEVATION" (degrees) and "FACTOR" (multiply data by this)
178 somewhere.
179 The second row must give the data type of the column. Use
180 'R' for Real and 'I' for Integer. An example file
181 would be:
[229]182
[242]183 TIME ELEVATION FACTOR
184 R R R
185 0.1 0 1.5
186 0.2 20 1.4
187 0.3 40 1.3
188 0.4 60 1.2
189 0.5 80 1.1
190 0.6 90 1.0
191 method: Interpolation method when correcting from a table. Values
192 are "nearest", "linear" (default), "cubic" and "spline"
[258]193 insitu: if False a new scantable is returned.
194 Otherwise, the scaling is done in-situ
195 The default is taken from .asaprc (False)
196 allaxes: if True apply to all spectra. Otherwise
197 apply only to the selected (beam/pol/if) spectra only
[435]198 The default is taken from .asaprc (True if none)
[229]199 """
[258]200 if allaxes is None: allaxes = rcParams['scantable.allaxes']
[242]201 if poly is None:
202 poly = ()
[258]203 if insitu is None: insitu = rcParams['insitu']
[411]204 from os.path import expandvars
205 filename = expandvars(filename)
[229]206 if not insitu:
207 from asap._asap import gainel as _gainEl
[258]208 return scantable(_gainEl(scan, poly, filename, method, allaxes))
[229]209 else:
210 from asap._asap import gainel_insitu as _gainEl
[258]211 _gainEl(scan, poly, filename, method, allaxes)
[229]212 return
[224]213
[399]214def freq_align(scan, reftime=None, method='cubic', perif=False, insitu=None):
[269]215 """
[313]216 Return a scan where all rows have been aligned in frequency. The
217 alignment frequency frame (e.g. LSRK) is that set by function
218 set_freqframe.
[269]219 scan: a scantable
[273]220 reftime: reference time to align at. By default, the time of
221 the first row of data is used.
[319]222 method: Interpolation method for regridding the spectra. Choose
223 from "nearest", "linear", "cubic" (default) and "spline"
[399]224 perif: Generate aligners per freqID (no doppler tracking) or
225 per IF (scan-based doppler tracking)
[269]226 insitu: if False a new scantable is returned.
227 Otherwise, the scaling is done in-situ
228 The default is taken from .asaprc (False)
229 """
[273]230 if reftime is None: reftime = ''
[269]231 if insitu is None: insitu = rcParams['insitu']
[399]232 perfreqid = not perif
[269]233 if not insitu:
[313]234 from asap._asap import freq_align as _align
[399]235 return scantable(_align(scan, reftime, method, perfreqid))
[269]236 else:
[313]237 from asap._asap import freq_align_insitu as _align
[399]238 _align(scan, reftime, method, perfreqid)
[269]239 return
240
[258]241def opacity(scan, tau, insitu=None, allaxes=None):
[242]242 """
243 Return a scan after applying an opacity correction.
244 Parameters:
245 scan: a scantable
246 tau: Opacity from which the correction factor is exp(tau*ZD)
247 where ZD is the zenith-distance
[258]248 insitu: if False a new scantable is returned.
249 Otherwise, the scaling is done in-situ
250 The default is taken from .asaprc (False)
251 allaxes: if True apply to all spectra. Otherwise
[242]252 apply only to the selected (beam/pol/if)spectra only
[435]253 The default is taken from .asaprc (True if none)
[242]254 """
[258]255 if allaxes is None: allaxes = rcParams['scantable.allaxes']
256 if insitu is None: insitu = rcParams['insitu']
[242]257 if not insitu:
258 from asap._asap import opacity as _opacity
[258]259 return scantable(_opacity(scan, tau, allaxes))
[242]260 else:
261 from asap._asap import opacity_insitu as _opacity
[258]262 _opacity(scan, tau, allaxes)
[242]263 return
264
[258]265def bin(scan, width=5, insitu=None):
[101]266 """
[167]267 Return a scan where all spectra have been binned up
[172]268 width: The bin width (default=5) in pixels
[258]269 insitu: if False a new scantable is returned.
270 Otherwise, the scaling is done in-situ
271 The default is taken from .asaprc (False)
[101]272 """
[258]273 if insitu is None: insitu = rcParams['insitu']
[167]274 if not insitu:
275 from asap._asap import bin as _bin
276 return scantable(_bin(scan, width))
277 else:
278 from asap._asap import bin_insitu as _bin
279 _bin(scan, width)
280 return
[113]281
[301]282def resample(scan, width=5, method='cubic', insitu=None):
283 """
284 Return a scan where all spectra have been binned up
285 width: The bin width (default=5) in pixels
286 method: Interpolation method when correcting from a table. Values
287 are "nearest", "linear", "cubic" (default) and "spline"
288 insitu: if False a new scantable is returned.
289 Otherwise, the scaling is done in-situ
290 The default is taken from .asaprc (False)
291 """
292 if insitu is None: insitu = rcParams['insitu']
293 if not insitu:
294 from asap._asap import resample as _resample
295 return scantable(_resample(scan, method, width))
296 else:
297 from asap._asap import resample_insitu as _resample
298 _resample(scan, method, width)
299 return
300
[316]301def average_pol(scan, mask=None, weight='none', insitu=None):
[113]302 """
303 Average the Polarisations together.
[305]304 The polarisation cursor of the output scan is set to 0
[113]305 Parameters:
[172]306 scan: The scantable
307 mask: An optional mask defining the region, where the
308 averaging will be applied. The output will have all
309 specified points masked.
[316]310 weight: Weighting scheme. 'none' (default), or 'var' (variance
311 weighted)
[258]312 insitu: if False a new scantable is returned.
313 Otherwise, the scaling is done in-situ
314 The default is taken from .asaprc (False)
[113]315 Example:
316 polav = average_pols(myscan)
317 """
318 if mask is None:
[166]319 mask = ()
[258]320 if insitu is None: insitu = rcParams['insitu']
[166]321 if not insitu:
322 from asap._asap import averagepol as _avpol
[316]323 return scantable(_avpol(scan, mask, weight))
[166]324 else:
325 from asap._asap import averagepol_insitu as _avpol
[316]326 _avpol(scan, mask, weight)
[166]327 return
[113]328
[258]329def smooth(scan, kernel="hanning", width=5.0, insitu=None, allaxes=None):
[113]330 """
[180]331 Smooth the spectrum by the specified kernel (conserving flux).
[113]332 Parameters:
[172]333 scan: The input scan
[180]334 kernel: The type of smoothing kernel. Select from
335 'hanning' (default), 'gaussian' and 'boxcar'.
336 The first three characters are sufficient.
337 width: The width of the kernel in pixels. For hanning this is
338 ignored otherwise it defauls to 5 pixels.
339 For 'gaussian' it is the Full Width Half
340 Maximum. For 'boxcar' it is the full width.
[258]341 insitu: if False a new scantable is returned.
[172]342 Otherwise, the scaling is done in-situ
[258]343 The default is taken from .asaprc (False)
344 allaxes: If True (default) apply to all spectra. Otherwise
[180]345 apply only to the selected (beam/pol/if)spectra only
[435]346 The default is taken from .asaprc (True if none)
[113]347 Example:
348 none
349 """
[258]350 if allaxes is None: allaxes = rcParams['scantable.allaxes']
351 if insitu is None: insitu = rcParams['insitu']
[172]352 if not insitu:
[180]353 from asap._asap import smooth as _smooth
[258]354 return scantable(_smooth(scan,kernel,width,allaxes))
[172]355 else:
[180]356 from asap._asap import smooth_insitu as _smooth
[258]357 _smooth(scan,kernel,width,allaxes)
[172]358 return
[113]359
[258]360def poly_baseline(scan, mask=None, order=0, insitu=None):
[113]361 """
[160]362 Return a scan which has been baselined (all rows) by a polynomial.
[113]363 Parameters:
364 scan: a scantable
365 mask: an optional mask
366 order: the order of the polynomial (default is 0)
[258]367 insitu: if False a new scantable is returned.
368 Otherwise, the scaling is done in-situ
369 The default is taken from .asaprc (False)
[113]370 Example:
371 # return a scan baselined by a third order polynomial,
372 # not using a mask
373 bscan = poly_baseline(scan, order=3)
374 """
375 from asap.asapfitter import fitter
376 if mask is None:
377 from numarray import ones
378 mask = tuple(ones(scan.nchan()))
379 f = fitter()
380 f._verbose(True)
381 f.set_scan(scan, mask)
382 f.set_function(poly=order)
[258]383 sf = f.auto_fit(insitu)
[113]384 return sf
[458]385
386def rotate_xyphase (scan, angle, allaxes=None):
387 """
388 Rotate the phase of the XY correlation. This is always done in situ
389 in the data. So if you call this function more than once
390 then each call rotates the phase further.
391 Parameters:
392 angle: The angle (degrees) to rotate (add) by.
393 allaxes: If True apply to all spectra. Otherwise
394 apply only to the selected (beam/pol/if)spectra only.
395 The default is taken from .asaprc (True if none)
396 Examples:
397 rotate_xyphase(scan, 2.3)
398 """
399 if allaxes is None: allaxes = rcParams['scantable.allaxes']
400 from asap._asap import rotate_xyphase as _rotate_xyphase
401 _rotate_xyphase(scan, angle, allaxes)
402 return
403
Note: See TracBrowser for help on using the repository browser.