Coverage for /wheeldirectory/casa-6.7.0-12-py3.10.el8/lib/py/lib/python3.10/site-packages/casatools/__casac__/measures.py: 64%

1# This file was automatically generated by SWIG (http://www.swig.org). 

2# Version 3.0.12 

3# 

4# Do not make changes to this file unless you know what you are doing--modify 

5# the SWIG interface file instead. 

6 

7from sys import version_info as _swig_python_version_info 

8if _swig_python_version_info >= (2, 7, 0): 

9 def swig_import_helper(): 

10 import importlib 

11 pkg = __name__.rpartition('.')[0] 

12 mname = '.'.join((pkg, '_measures')).lstrip('.') 

13 try: 

14 return importlib.import_module(mname) 

15 except ImportError: 

16 return importlib.import_module('_measures') 

17 _measures = swig_import_helper() 

18 del swig_import_helper 

19elif _swig_python_version_info >= (2, 6, 0): 

20 def swig_import_helper(): 

21 from os.path import dirname 

22 import imp 

23 fp = None 

24 try: 

25 fp, pathname, description = imp.find_module('_measures', [dirname(__file__)]) 

26 except ImportError: 

27 import _measures 

28 return _measures 

29 try: 

30 _mod = imp.load_module('_measures', fp, pathname, description) 

31 finally: 

32 if fp is not None: 

33 fp.close() 

34 return _mod 

35 _measures = swig_import_helper() 

36 del swig_import_helper 

37else: 

38 import _measures 

39del _swig_python_version_info 

40 

41try: 

42 _swig_property = property 

43except NameError: 

44 pass # Python < 2.2 doesn't have 'property'. 

45 

46try: 

47 import builtins as __builtin__ 

48except ImportError: 

49 import __builtin__ 

50 

51def _swig_setattr_nondynamic(self, class_type, name, value, static=1): 

52 if (name == "thisown"): 

53 return self.this.own(value) 

54 if (name == "this"): 

55 if type(value).__name__ == 'SwigPyObject': 

56 self.__dict__[name] = value 

57 return 

58 method = class_type.__swig_setmethods__.get(name, None) 

59 if method: 

60 return method(self, value) 

61 if (not static): 

62 if _newclass: 

63 object.__setattr__(self, name, value) 

64 else: 

65 self.__dict__[name] = value 

66 else: 

67 raise AttributeError("You cannot add attributes to %s" % self) 

68 

69 

70def _swig_setattr(self, class_type, name, value): 

71 return _swig_setattr_nondynamic(self, class_type, name, value, 0) 

72 

73 

74def _swig_getattr(self, class_type, name): 

75 if (name == "thisown"): 

76 return self.this.own() 

77 method = class_type.__swig_getmethods__.get(name, None) 

78 if method: 

79 return method(self) 

80 raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name)) 

81 

82 

83def _swig_repr(self): 

84 try: 

85 strthis = "proxy of " + self.this.__repr__() 

86 except __builtin__.Exception: 

87 strthis = "" 

88 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) 

89 

90try: 

91 _object = object 

92 _newclass = 1 

93except __builtin__.Exception: 

94 class _object: 

95 pass 

96 _newclass = 0 

97 

98class measures(_object): 

99 """Proxy of C++ casac::measures class.""" 

100 

101 __swig_setmethods__ = {} 

102 __setattr__ = lambda self, name, value: _swig_setattr(self, measures, name, value) 

103 __swig_getmethods__ = {} 

104 __getattr__ = lambda self, name: _swig_getattr(self, measures, name) 

105 __repr__ = _swig_repr 

106 

107 def __init__(self): 

108 """__init__(self) -> measures""" 

109 this = _measures.new_measures() 

110 try: 

111 self.this.append(this) 

112 except __builtin__.Exception: 

113 self.this = this 

114 

115 def dirshow(self, *args, **kwargs): 

116 """ 

117 dirshow(self, _v) -> string 

118 

119 

120 

121 Summary: 

122 Show direction measure as a string.  

123 

124 Description: 

125 

126 

127 dirshow will convert a direction measure to a string 

128 

129 Input Parameters: 

130 v a direction measure value to be converted to string  

131 

132 Example: 

133 

134 print 't----t dirshow Ex 1 t----' 

135 print me.dirshow(me.direction('venus')) 

136 #[0, 90] deg VENUS 

137 

138 -------------------------------------------------------------------------------- 

139 

140 """ 

141 return _measures.measures_dirshow(self, *args, **kwargs) 

142 

143 

144 def show(self, *args, **kwargs): 

145 """ 

146 show(self, _v, _refcode) -> string 

147 

148 

149 

150 Summary: 

151 Show a measure as a string  

152 

153 Description: 

154 

155 

156 show will convert a measure to a string. 

157 

158 All measures are catered for (at this moment {em direction, position, epoch, 

159 radialvelocity, frequency, doppler, baseline, uvw, earthmagnetic} ). 

160 

161 Input Parameters: 

162 v measure value to be converted to string 

163 refcode add the reference code to output 

164 

165 Example: 

166 

167 print 't----t show Ex 1 t----' 

168 print me.show(me.frequency('lsrk', qa.constants('HI'))) 

169 #1.42041e+09 Hz LSRK 

170 print me.show(me.frequency('lsrk', qa.constants('HI')), refcode=false) 

171 #1.42041e+09 Hz 

172 

173 -------------------------------------------------------------------------------- 

174 

175 """ 

176 return _measures.measures_show(self, *args, **kwargs) 

177 

178 

179 def epoch(self, *args, **kwargs): 

180 """ 

181 epoch(self, _rf, _v0, _off) -> record * 

182 

183 

184 

185 Summary: 

186 define an epoch measure 

187 

188 Description: 

189 

190 

191 epoch defines an epoch measure from the CLI. It has to specify a 

192 reference code, an epoch quantity value (see introduction for the 

193 action on a scalar quantity with either a vector or scalar value), 

194 

195 and optionally it can specify an offset, which in itself has to be an 

196 epoch. Allowable reference codes are: 

197 {em UTC TAI LAST LMST GMST1 GAST UT1 UT2 TDT TCG TDB TCB}. 

198 Note that additional ones may become available. Check in casa with: 

199 

200 begin{verbatim} 

201 print 't----t epoch Ex 1 t----' 

202 print me.listcodes(me.epoch()) 

203 #{'normal': ['LAST', 'LMST', 'GMST1', 'GAST', 'UT1', 'UT2', 'UTC', 'TAI', 

204 # 'TDT', 'TCG', 'TDB', 'TCB', 'IAT', 'GMST', 'TT', 'ET', 'UT'], 'extra': []} 

205 # 

206 end{verbatim} 

207 

208 See quantity for possible time formats. 

209 

210 Input Parameters: 

211 rf reference code 

212 v0 epoch value 

213 off optional offset epoch measure 

214 

215 Example: 

216 

217 print 't----t epoch Ex 2 t----' 

218 print me.epoch('utc','today') 

219 #{'m0': {'value': 54048.861237743055, 'unit': 'd'}, 

220 # 'refer': 'UTC', 

221 # 'type': 'epoch'} 

222 

223 -------------------------------------------------------------------------------- 

224 

225 """ 

226 return _measures.measures_epoch(self, *args, **kwargs) 

227 

228 

229 def direction(self, *args, **kwargs): 

230 """ 

231 direction(self, _rf, _v0, _v1, _off) -> record * 

232 

233 

234 

235 Summary: 

236 define a direction measure 

237 

238 Description: 

239 

240 

241 direction defines a direction measure from the CLI. It has to specify a 

242 reference code, direction quantity values (see introduction for the action on a 

243 scalar quantity with either a vector or scalar value), 

244 

245 and optionally it can specify an 

246 offset, which in itself has to be a direction. Allowable reference codes are: 

247 {em J2000 JMEAN JTRUE APP B1950 BMEAN BTRUE GALACTIC HADEC AZEL 

248 SUPERGAL ECLIPTIC MECLIPTIC TECLIPTIC MERCURY 

249 VENUS MARS JUPITER SATURN URANUS NEPTUNE PLUTO MOON SUN COMET}. 

250 Note that additional ones may become available. Check in casa with: 

251 

252 begin{verbatim} 

253 print 't----t direction Ex 1 t----' 

254 print me.listcodes(me.direction()) 

255 #{'normal': ['J2000', 'JMEAN', 'JTRUE', 'APP', 'B1950', 'BMEAN', 

256 #'BTRUE', 'GALACTIC', 'HADEC', 'AZEL', 'AZELSW', 'AZELNE', 'AZELGEO', 

257 #'AZELSWGEO', 'AZELNEGEO', 'JNAT', 'ECLIPTIC', 'MECLIPTIC', 

258 #'TECLIPTIC', 'SUPERGAL', 'ITRF', 'TOPO', 'ICRS'], 'extra': ['MERCURY', 

259 #'VENUS', 'MARS', 'JUPITER', 'SATURN', 'URANUS', 'NEPTUNE', 'PLUTO', 

260 #'SUN', 'MOON', 'COMET']} 

261 end{verbatim} 

262 

263 The direction quantity values should be longitude(angle) and 

264 latitude(angle) (none needed for planets: the frame epoch defines coordinates). 

265 See quantity for possible angle formats. 

266 

267 Input Parameters: 

268 rf reference code 

269 v0 longitude 

270 v1 latitude 

271 off optional offset direction measure 

272 

273 Example: 

274 

275 print 't----t direction Ex 2 t----' 

276 print me.direction('j2000','30deg','40deg') 

277 #{'m0': {'value': 0.52359877559829882, 'unit': 'rad'}, 

278 # 'm1': {'value': 0.69813170079773168, 'unit': 'rad'}, 

279 # 'refer': 'J2000', 

280 # 'type': 'direction'} 

281 # 

282 print me.direction('mars') 

283 #{'m0': {'value': 0.0, 'unit': 'rad'}, 

284 # 'm1': {'value': 1.5707963267948966, 'unit': 'rad'}, 

285 # 'refer': 'MARS', 

286 # 'type': 'direction'} 

287 

288 -------------------------------------------------------------------------------- 

289 

290 """ 

291 return _measures.measures_direction(self, *args, **kwargs) 

292 

293 

294 def getvalue(self, *args, **kwargs): 

295 """ 

296 getvalue(self, _v) -> record * 

297 

298 

299 

300 Summary: 

301 get the value of a measure 

302 

303 Description: 

304 

305 

306 getvalue gets the actual implementation value of the measure. 

307 

308 Input Parameters: 

309 v measure (array of measures) 

310 

311 Example: 

312 

313 print 't----t getvalue Ex 1 t----' 

314 b=me.direction('j2000','0deg','80deg') 

315 print me.getvalue(b) 

316 #{'m0': {'value': 0.0, 'unit': 'rad'}, 

317 # 'm1': {'value': 1.3962634015954634, 'unit': 'rad'}} 

318 

319 -------------------------------------------------------------------------------- 

320 

321 """ 

322 return _measures.measures_getvalue(self, *args, **kwargs) 

323 

324 

325 def gettype(self, *args, **kwargs): 

326 """ 

327 gettype(self, _v) -> string 

328 

329 

330 

331 Summary: 

332 get the type of a measure 

333 

334 Description: 

335 

336 

337 gettype gets the actual type of the measure. 

338 

339 Input Parameters: 

340 v measure (array of measures) 

341 

342 Example: 

343 

344 print 't----t gettype Ex 1 t----' 

345 b=me.direction('j2000','0deg','80deg') 

346 print me.getvalue(b) 

347 #{'m0': {'value': 0.0, 'unit': 'rad'}, 

348 # 'm1': {'value': 1.3962634015954634, 'unit': 'rad'}} 

349 print me.gettype(b) 

350 #'Direction' 

351 

352 -------------------------------------------------------------------------------- 

353 

354 """ 

355 return _measures.measures_gettype(self, *args, **kwargs) 

356 

357 

358 def getref(self, *args, **kwargs): 

359 """ 

360 getref(self, _v) -> string 

361 

362 

363 

364 Summary: 

365 get the reference code of a measure 

366 

367 Description: 

368 

369 

370 gettype gets the actual reference code of the measure. 

371 

372 Input Parameters: 

373 v measure (array of measures) 

374 

375 Example: 

376 

377 print 't----t getref Ex 1 t----' 

378 b=me.direction('j2000','0deg','80deg') 

379 print me.getvalue(b) 

380 #{'m0': {'value': 0.0, 'unit': 'rad'}, 

381 # 'm1': {'value': 1.3962634015954634, 'unit': 'rad'}} 

382 print me.gettype(b) 

383 #'Direction' 

384 print me.getref(b) 

385 #'J2000' 

386 

387 -------------------------------------------------------------------------------- 

388 

389 """ 

390 return _measures.measures_getref(self, *args, **kwargs) 

391 

392 

393 def getoffset(self, *args, **kwargs): 

394 """ 

395 getoffset(self, _v) -> record * 

396 

397 

398 

399 Summary: 

400 get the offset of a measure 

401 

402 Description: 

403 

404 

405 getoff gets the actual offset of the measure (as a measure) or F if no offset 

406 given. 

407 

408 Input Parameters: 

409 v measure (array of measures) 

410 

411 Example: 

412 

413 print 't----t getoffset Ex 1 t----' 

414 b=me.direction('j2000','0deg','80deg') 

415 print me.getvalue(b) 

416 #{'m0': {'value': 0.0, 'unit': 'rad'}, 

417 # 'm1': {'value': 1.3962634015954634, 'unit': 'rad'}} 

418 print me.gettype(b) 

419 #'Direction' 

420 print me.getref(b) 

421 #'J2000' 

422 print me.getoffset(b) 

423 #{} 

424 

425 -------------------------------------------------------------------------------- 

426 

427 """ 

428 return _measures.measures_getoffset(self, *args, **kwargs) 

429 

430 

431 def cometname(self): 

432 """ 

433 cometname(self) -> string 

434 

435 

436 

437 Summary: 

438 get the current comet name 

439 

440 Description: 

441 

442 

443 cometname gets the name of the current comet (if any). 

444 

445 Example: 

446 

447 print 't----t cometname Ex 1 t----' 

448 print me.cometname() 

449 #Thu Nov 9 21:27:25 2006 WARN : 

450 #Method cometname fails! No Comet table present 

451 #'' 

452 

453 -------------------------------------------------------------------------------- 

454 

455 """ 

456 return _measures.measures_cometname(self) 

457 

458 

459 def comettype(self): 

460 """ 

461 comettype(self) -> string 

462 

463 

464 

465 Summary: 

466 get the current comet table type 

467 

468 Description: 

469 

470 

471 comettype gets the comet table type (apparent or topocentric) 

472 

473 Example: 

474 

475 print 't----t comettype Ex 1 t----' 

476 print me.comettype() 

477 # 'none' 

478 

479 -------------------------------------------------------------------------------- 

480 

481 """ 

482 return _measures.measures_comettype(self) 

483 

484 

485 def cometdist(self): 

486 """ 

487 cometdist(self) -> record * 

488 

489 

490 

491 Summary: 

492 get the distance of the current comet in the current frame 

493 

494 Description: 

495 

496 

497 cometdist returns the distance in AU of the current comet in the current frame, 

498 as a quantity. It will return -1 AU on failure! 

499 

500 

501 Example: 

502 

503 print 't----t cometdist Ex 1 t----' 

504 # Directory with several Solar System ephemerides for setjy. 

505 cometdir = os.getenv('CASAPATH').split()[0] + '/data/ephemerides/JPL-Horizons/' 

506 me.framecomet(cometdir + 'Ganymede_55438-56292dUTC.tab') 

507 # Out[5]: True 

508 me.doframe(me.epoch('utc', '2011/01/03/17:00:00')) 

509 me.doframe(me.observatory('ALMA')) 

510 gandist = me.cometdist() 

511 print gandist 

512 # {'value': 5.1241088343892631, 'unit': 'AU'} 

513 

514 -------------------------------------------------------------------------------- 

515 

516 """ 

517 return _measures.measures_cometdist(self) 

518 

519 

520 def cometangdiam(self): 

521 """ 

522 cometangdiam(self) -> record * 

523 

524 

525 

526 Summary: 

527 get the angular diameter of the current comet in the current frame 

528 

529 Description: 

530 

531 

532 cometdist returns the angular diameter (as seen from Earth) in AU of the current 

533 comet in the current frame, as a quantity. It will return -1 radians on failure! 

534 

535 

536 Example: 

537 

538 print 't----t cometangdiam Ex 1 t----' 

539 # Directory with several Solar System ephemerides for setjy. 

540 cometdir = os.getenv('CASAPATH').split()[0] + '/data/ephemerides/JPL-Horizons/' 

541 me.framecomet(cometdir + 'Ganymede_55438-56292dUTC.tab') 

542 # Out[5]: True 

543 me.doframe(me.epoch('utc', '2011/01/03/17:00:00')) 

544 me.doframe(me.observatory('ALMA')) 

545 gad = me.cometangdiam() 

546 print gad 

547 # {'unit': 'rad', 'value': 6.8679673431729014e-06} 

548 

549 -------------------------------------------------------------------------------- 

550 

551 """ 

552 return _measures.measures_cometangdiam(self) 

553 

554 

555 def comettopo(self): 

556 """ 

557 comettopo(self) -> record * 

558 

559 

560 

561 Summary: 

562 get the current comet table coordinates 

563 

564 Description: 

565 

566 

567 comettopo gets the comet table's topographic coordinates used. 

568 

569 Example: 

570 

571 print 't----t comettopo Ex 1 t----' 

572 print me.comettopo() 

573 #Thu Nov 9 21:45:40 2006 WARN : 

574 #Method comettopo fails! No Topocentric Comet table present 

575 #{'value': [0.0], 'unit': ''} 

576 

577 -------------------------------------------------------------------------------- 

578 

579 """ 

580 return _measures.measures_comettopo(self) 

581 

582 

583 def framecomet(self, *args, **kwargs): 

584 """ 

585 framecomet(self, _v) -> bool 

586 

587 

588 

589 Summary: 

590 set the current comet table 

591 

592 Description: 

593 

594 

595 framecomet will put the specified comet table in the frame. 

596 

597 Input Parameters: 

598 v name of a table 

599 

600 Example: 

601 

602 print 't----t framecomet Ex 1 t----' 

603 print me.framecomet('VGEO') 

604 #True 

605 print me.showframe() 

606 #'Frame: VENUS comet between MJD 50802.7 and 50803.1' 

607 print me.cometname() 

608 #'VENUS' 

609 print me.comettype() 

610 #'APP' 

611 print me.doframe(me.epoch('et',qa.quantity('1997/12/20/17:30:0'))) 

612 #True 

613 print me.measure(me.direction('comet'),'app') 

614 #{'m0': {'value': -0.94936485919663083, 'unit': 'rad'}, 

615 # 'm1': {'value': -0.34710256485894436, 'unit': 'rad'}, 

616 # 'refer': 'APP', 

617 # 'type': 'direction'} 

618 

619 -------------------------------------------------------------------------------- 

620 

621 """ 

622 return _measures.measures_framecomet(self, *args, **kwargs) 

623 

624 

625 def position(self, *args, **kwargs): 

626 """ 

627 position(self, _rf, _v0, _v1, _v2, _off) -> record * 

628 

629 

630 

631 Summary: 

632 define a position measure 

633 

634 Description: 

635 

636 

637 position defines a position measure from the CLI. It has to specify a 

638 reference code, position quantity values (see introduction for the action on a 

639 scalar quantity with either a vector or scalar value), 

640 

641 and optionally it can specify an 

642 offset, which in itself has to be a position. Allowable reference codes are: 

643 {em WGS84 ITRF} (World Geodetic System and International Terrestrial 

644 Reference Frame). 

645 Note that additional ones may become available. Check in casa with: 

646 

647 begin{verbatim} 

648 print 't----t position Ex 1 t----' 

649 print me.listcodes(me.position()) 

650 #{'normal': ['ITRF', 'WGS84'], 'extra': []} 

651 end{verbatim} 

652 

653 The position quantity values should be either longitude 

654 (angle), latitude(angle) and height(length); or x,y,z (length). 

655 See quantity for possible angle formats. 

656 

657 Input Parameters: 

658 rf reference code 

659 v0 longitude or x 

660 v1 latitude or y 

661 v2 height or z 

662 off optional offset position measure 

663 

664 Example: 

665 

666 print 't----t position Ex 2 t----' 

667 print me.position('wgs84','30deg','40deg','10m') 

668 #{'m0': {'value': 0.52359877559829882, 'unit': 'rad'}, 

669 # 'm1': {'value': 0.6981317007977319, 'unit': 'rad'}, 

670 # 'm2': {'value': 9.9999999999999982, 'unit': 'm'}, 

671 # 'refer': 'WGS84', 

672 # 'type': 'position'} 

673 print me.observatory('ATCA') 

674 #{'m0': {'value': 2.6101423190348916, 'unit': 'rad'}, 

675 # 'm1': {'value': -0.5261379196128062, 'unit': 'rad'}, 

676 # 'm2': {'value': 6372960.2577234386, 'unit': 'm'}, 

677 # 'refer': 'ITRF', 

678 # 'type': 'position'} 

679 

680 ###One can use a quantity-vectors especially when dealing with multiple antenna positions for e.g for 3 positions 

681 

682 ants=me.position('itrf',qa.quantity([3828763.11,3828746.55, 3828727.43],'m'), qa.quantity([442449.106,442592.14, 442580.12],'m'), 

683 qa.quantity([5064923.01, 5064923.01, 5064923.51],'m')) 

684 

685 print ants 

686 

687 #{'m0': {'unit': 'rad', 

688 # 'value': array([ 0.11504897, 0.11508633, 0.1150838 ])}, 

689 # 'm1': {'unit': 'rad', 

690 # 'value': array([ 0.92031276, 0.92031276, 0.92031535])}, 

691 # 'm2': {'unit': 'm', 

692 # 'value': array([ 6364639.28758924, 6364639.27051283, 6364627.33064587])}, 

693 # 'refer': 'ITRF', 

694 # 'type': 'position'} 

695 

696 -------------------------------------------------------------------------------- 

697 

698 """ 

699 return _measures.measures_position(self, *args, **kwargs) 

700 

701 

702 def observatory(self, *args, **kwargs): 

703 """ 

704 observatory(self, _name) -> record * 

705 

706 

707 

708 Summary: 

709 get position of an observatory 

710 

711 Description: 

712 

713 

714 observatory will give you the position of an observatory as given in the 

715 system. At the time of writing the following observatories are recognised 

716 (but check e.g. the position GUI for currently known ones, or the 

717 me.obslist() tool function):: 

718 

719 {'ALMA' 'ARECIBO' 'ATCA' 'BIMA' 'CLRO' 'DRAO' 'DWL' 'GB' 'GBT' 'GMRT' 

720 'IRAM PDB' 'IRAM_PDB' 'JCMT' 'MOPRA' 'MOST' 'NRAO12M' 'NRAO_GBT' 'PKS' 

721 'SAO SMA' 'SMA' 'VLA' 'VLBA' 'WSRT' 'ATF' 'ATA' 'CARMA' 'ACA' 'OSF' 

722 'OVRO_MMA' 'EVLA' 'ASKAP' 'APEX' 'SMT' 'NRO' 'ASTE' 'LOFAR' 'MeerKAT' 

723 'KAT-7' 'EVN' 'LWA1' 'PAPER_SA' 'PAPER_GB' 'e-MERLIN' 'MERLIN2' 

724 'Effelsberg' 'MWA32T' }. 

725 

726 Input Parameters: 

727 name observatory name - case insensitive 

728 

729 Example: 

730 

731 print 't----t observatory Ex 1 t----' 

732 print me.observatory('ATCA') 

733 #{'m0': {'value': 2.6101423190348916, 'unit': 'rad'}, 

734 # 'm1': {'value': -0.5261379196128062, 'unit': 'rad'}, 

735 # 'm2': {'value': 6372960.2577234386, 'unit': 'm'}, 

736 # 'refer': 'ITRF', 

737 # 'type': 'position'} 

738 

739 -------------------------------------------------------------------------------- 

740 

741 """ 

742 return _measures.measures_observatory(self, *args, **kwargs) 

743 

744 

745 def obslist(self): 

746 """ 

747 obslist(self) -> std::vector< std::string > 

748 

749 

750 

751 Summary: 

752 get a list of known observatories 

753 

754 Description: 

755 

756 

757 obslist will give you an array of strings of the 

758 observatories known in the Observatories table. 

759 

760 Example: 

761 

762 print 't----t obslist Ex 1 t----' 

763 print me.obslist() 

764 

765 #['ALMA' 'ARECIBO' 'ATCA' 'BIMA' 'CLRO' 'DRAO' 'DWL' 'GB' 'GBT' 'GMRT' 

766 #'IRAM PDB' 'IRAM_PDB' 'JCMT' 'MOPRA' 'MOST' 'NRAO12M' 'NRAO_GBT' 'PKS' 

767 #'SAO SMA' 'SMA' 'VLA' 'VLBA' 'WSRT' 'ATF' 'ATA' 'CARMA' 'ACA' 'OSF' 

768 #'OVRO_MMA' 'EVLA' 'ASKAP' 'APEX' 'SMT' 'NRO' 'ASTE' 'LOFAR' 'MeerKAT' 

769 #'KAT-7' 'EVN' 'LWA1' 'PAPER_SA' 'PAPER_GB' 'e-MERLIN' 'MERLIN2' 

770 #'Effelsberg' 'MWA32T'] 

771 

772 -------------------------------------------------------------------------------- 

773 

774 """ 

775 return _measures.measures_obslist(self) 

776 

777 

778 def linelist(self): 

779 """ 

780 linelist(self) -> string 

781 

782 

783 

784 Summary: 

785 get a list of known spectral lines 

786 

787 Description: 

788 

789 

790 linelist will give you a string with a space separated list of spectral lines 

791 known in the Lines table. 

792 

793 A number of lines are available now, but tables with many lines are 

794 already online, and will be interfaced once a nomenclature can be defined for 

795 the tens of thousands of lines. 

796 

797 Example: 

798 

799 print 't----t linelist Ex 1 t----' 

800 print me.linelist() 

801 #'C109A CI CII166A DI H107A H110A H138B H166A H240A H272A 

802 # H2CO HE110A HE138B HI OH1612 OH1665 OH1667 OH1720' 

803 

804 -------------------------------------------------------------------------------- 

805 

806 """ 

807 return _measures.measures_linelist(self) 

808 

809 

810 def spectralline(self, *args, **kwargs): 

811 """ 

812 spectralline(self, _name) -> record * 

813 

814 

815 

816 Summary: 

817 get frequency of a spectral line 

818 

819 Description: 

820 

821 

822 spectralline will give you the frequency of a spectral line. The known list 

823 can be obtained by me.linelist(). 

824 

825 Input Parameters: 

826 name name 

827 

828 Example: 

829 

830 print 't----t spectralline Ex 1 t----' 

831 print me.spectralline('HI') 

832 #{'m0': {'value': 1420405751.786, 'unit': 'Hz'}, 

833 # 'refer': 'REST', 

834 # 'type': 'frequency'} 

835 

836 -------------------------------------------------------------------------------- 

837 

838 """ 

839 return _measures.measures_spectralline(self, *args, **kwargs) 

840 

841 

842 def sourcelist(self): 

843 """ 

844 sourcelist(self) -> string 

845 

846 

847 

848 Summary: 

849 get a list of known sources 

850 

851 Description: 

852 

853 

854 sourcelist will give you a string with the space separated list of sources 

855 known in the Sources table. 

856 

857 Example: 

858 

859 print 't----t sourcelist Ex 1 t----' 

860 print me.sourcelist()[0:62] 

861 #'0002-478 0003+380 0003-066 0007+106 0007+171 0008-264 0008-421' 

862 #...... 

863 

864 -------------------------------------------------------------------------------- 

865 

866 """ 

867 return _measures.measures_sourcelist(self) 

868 

869 

870 def source(self, *args, **kwargs): 

871 """ 

872 source(self, _name) -> record * 

873 

874 

875 

876 Summary: 

877 get direction of a source 

878 

879 Description: 

880 

881 

882 source will give you the direction of a source. The known list 

883 can be obtained by me.sourcelist(). 

884 

885 Input Parameters: 

886 name name 

887 

888 Example: 

889 

890 print 't----t source Ex 1 t----' 

891 print me.source() 

892 print me.source('1934-638') 

893 # Out[19]: 

894 #{'m0': {'value': -1.1370073467795063, 'unit': 'rad'}, 

895 # 'm1': {'value': -1.1119959323803881, 'unit': 'rad'}, 

896 # 'refer': 'ICRS', 

897 # 'type': 'direction'} 

898 

899 -------------------------------------------------------------------------------- 

900 

901 """ 

902 return _measures.measures_source(self, *args, **kwargs) 

903 

904 

905 def frequency(self, *args, **kwargs): 

906 """ 

907 frequency(self, _rf, _v0, _off) -> record * 

908 

909 

910 

911 Summary: 

912 define a frequency measure 

913 

914 Description: 

915 

916 

917 frequency defines a frequency measure from the CLI. It has to specify a 

918 reference code, frequency quantity value (see introduction for the action on a 

919 scalar quantity with either a vector or scalar value), 

920 

921 and optionally it can specify an 

922 offset, which in itself has to be a frequency. Allowable reference codes are: 

923 {em REST LSRK LSRD BARY GEO TOPO GALACTO LGROUP CMB}. 

924 Note that additional ones may become available. Check in casa with: 

925 begin{verbatim} 

926 print 't----t frequency Ex 1 t----' 

927 print me.listcodes(me.frequency()) 

928 #{'normal': ['REST', 'LSRK', 'LSRD', 'BARY', 'GEO', 'TOPO', 

929 # 'GALACTO', 'LGROUP', 'CMB'], 'extra': []} 

930 end{verbatim} 

931 

932 The frequency quantity values should be in one of the recognised units 

933 (examples all give same frequency): 

934 begin{itemize} 

935 item value with time units: a period (0.5s) 

936 item value as frequency: 2Hz 

937 item value in angular frequency: 720deg/s 

938 item value as length: 149896km 

939 item value as wave number: 4.19169e-8m-1 

940 item value as energy (h.nu): 8.27134e-9ueV 

941 item value as momentum: 4.42044e-42kg.m 

942 end{itemize} 

943 

944 Input Parameters: 

945 rf reference code 

946 v0 frequency/wavelength/ldots 

947 off optional offset frequency measure 

948 

949 Example: 

950 

951 print 't----t frequency Ex 2 t----' 

952 print me.frequency('lsrk','5GHz') 

953 #{'m0': {'value': 5000000000.0, 'unit': 'Hz'}, 

954 # 'refer': 'LSRK', 

955 # 'type': 'frequency'} 

956 print me.frequency('lsrk','21cm') 

957 #{'m0': {'value': 1427583133.3333333, 'unit': 'Hz'}, 

958 # 'refer': 'LSRK', 

959 # 'type': 'frequency'} 

960 

961 -------------------------------------------------------------------------------- 

962 

963 """ 

964 return _measures.measures_frequency(self, *args, **kwargs) 

965 

966 

967 def doppler(self, *args, **kwargs): 

968 """ 

969 doppler(self, _rf, _v0, _off) -> record * 

970 

971 

972 

973 Summary: 

974 define a doppler measure 

975 

976 Description: 

977 

978 

979 doppler defines a doppler measure from the CLI. It has to specify a 

980 reference code, doppler quantity value (see introduction for the action on a 

981 scalar quantity with either a vector or scalar value), 

982 

983 and optionally it can specify an offset, 

984 which in itself has to be a doppler. Allowable reference codes are: 

985 {em RADIO Z RATIO BETA GAMMA OPTICAL TRUE RELATIVISTIC}. 

986 Note that additional ones may become available. Check in casa with: 

987 

988 begin{verbatim} 

989 print 't----t doppler Ex 1 t----' 

990 print me.listcodes(me.doppler()) 

991 #{'normal': ['RADIO', 'Z', 'RATIO', 'BETA', 'GAMMA', 'OPTICAL', 

992 # 'TRUE', 'RELATIVISTIC'], 'extra': []} 

993 end{verbatim} 

994 

995 The doppler quantity values should be either non-dimensioned to specify a 

996 ratio of the light velocity, or in velocity. 

997 

998 Input Parameters: 

999 rf reference code 

1000 v0 doppler ratio/velocity 

1001 off optional offset doppler measure 

1002 

1003 Example: 

1004 

1005 Examples both give same doppler: 

1006 

1007 print 't----t doppler Ex 2 t----' 

1008 print me.doppler('radio','0.4') 

1009 #{'m0': {'value': 119916983.2, 'unit': 'm/s'}, 

1010 # 'refer': 'RADIO', 

1011 # 'type': 'doppler'} 

1012 print me.doppler('radio',qa.mul(qa.quantity('0.4'),qa.constants('c'))) 

1013 #{'m0': {'value': 119916983.2, 'unit': 'm/s'}, 

1014 # 'refer': 'RADIO', 

1015 # 'type': 'doppler'} 

1016 

1017 -------------------------------------------------------------------------------- 

1018 

1019 """ 

1020 return _measures.measures_doppler(self, *args, **kwargs) 

1021 

1022 

1023 def radialvelocity(self, *args, **kwargs): 

1024 """ 

1025 radialvelocity(self, _rf, _v0, _off) -> record * 

1026 

1027 

1028 

1029 Summary: 

1030 define a radialvelocity measure 

1031 

1032 Description: 

1033 

1034 

1035 radialvelocity defines a radialvelocity measure from the CLI. It has to 

1036 specify a reference code, radialvelocity quantity value (see introduction for 

1037 the action on a 

1038 scalar quantity with either a vector or scalar value), 

1039 

1040 and optionally it 

1041 can specify an offset, which in itself has to be a radialvelocity. 

1042 Allowable reference codes are: 

1043 {em LSRK LSRD BARY GEO TOPO GALACTO LGROUP CMB}. 

1044 Note that additional ones may become available. Check in casa with: 

1045 

1046 begin{verbatim} 

1047 print 't----t radialvelocity Ex 1 t----' 

1048 print me.listcodes(me.radialvelocity()) 

1049 # Out[17]: 

1050 #{'extra': [], 

1051 # 'normal': ['LSRK', 'LSRD', 'BARY', 'GEO', 'TOPO', 'GALACTO', 

1052 # 'LGROUP', 'CMB']} 

1053 end{verbatim} 

1054 The radialvelocity quantity values should be given as velocity. 

1055 

1056 Input Parameters: 

1057 rf reference code 

1058 v0 radial velocity 

1059 off optional offset radialvelocity measure 

1060 

1061 Example: 

1062 

1063 print 't----t radialvelocity Ex 2 t----' 

1064 print me.radialvelocity('lsrk','20km/s') 

1065 # Out[18]: 

1066 #{'m0': {'value': 20000.0, 'unit': 'm/s'}, 

1067 # 'refer': 'LSRK', 

1068 # 'type': 'radialvelocity'} 

1069 

1070 -------------------------------------------------------------------------------- 

1071 

1072 """ 

1073 return _measures.measures_radialvelocity(self, *args, **kwargs) 

1074 

1075 

1076 def shift(self, *args, **kwargs): 

1077 """ 

1078 shift(self, _v, _offset, _pa) -> record * 

1079 

1080 

1081 

1082 Summary: 

1083 Shift a direction measure by an offset angle at a position angle. 

1084 

1085 Description: 

1086 

1087 

1088 This method calculates the direction measure located at the specified offset angular amount along the specified 

1089 position angle from the specified direction measure. 

1090 

1091 

1092 Input Parameters: 

1093 v The direction measure to shift, represented as a record. 

1094 offset The angular offset, represented as a quantity record or string. 

1095 pa Position angle of the offset, measured from the positive latitude axis through the positive longitude axis. 

1096 

1097 Example: 

1098 

1099 v = me.direction('J2000', '13:22:44', '-50.20.20') 

1100 # shift along 4 arcminues at a pa of 30 degrees. 

1101 offset = me.shift(v, offset='4arcmin', pa='30deg') 

1102 

1103 -------------------------------------------------------------------------------- 

1104 

1105 """ 

1106 return _measures.measures_shift(self, *args, **kwargs) 

1107 

1108 

1109 def uvw(self, *args, **kwargs): 

1110 """ 

1111 uvw(self, _rf, _v0, _v1, _v2, _off) -> record * 

1112 

1113 

1114 

1115 Summary: 

1116 define a uvw measure 

1117 

1118 Description: 

1119 

1120 

1121 uvw defines a uvw measure from the CLI. It has to specify a 

1122 reference code, uvw quantity values (see introduction for the action on a 

1123 scalar quantity with either a vector or scalar value), and optionally it can specify an 

1124 offset, which in itself has to be a uvw. Allowable reference codes are 

1125 ITRF and the direction ones. 

1126 

1127 Note that additional ones may become available. Check in casa with:: 

1128 

1129 print 't----t uvw Ex 1 t----' 

1130 print me.listcodes(me.uvw()) 

1131 

1132 { 

1133 'normal': array(['J2000', 'JMEAN', 'JTRUE', 'APP', 'B1950', 'B1950_VLA', 'BMEAN', 

1134 'BTRUE', 'GALACTIC', 'HADEC', 'AZEL', 'AZELSW', 'AZELNE', 'AZELGEO', 

1135 'AZELSWGEO', 'AZELNEGEO', 'JNAT', 'ECLIPTIC', 'MECLIPTIC', 

1136 'TECLIPTIC', 'SUPERGAL', 'ITRF', 'TOPO', 'ICRS'], dtype='|S10'), 

1137 'extra': array([], dtype='|S1') 

1138 } 

1139 

1140 The uvw quantity values should be either longitude 

1141 (angle), latitude(angle) and height(length); or x,y,z (length). 

1142 See quantity for possible angle formats. 

1143 

1144 Input Parameters: 

1145 rf reference code 

1146 v0 longitude or x 

1147 v1 latitude or y 

1148 v2 height or z 

1149 off optional offset uvw measure 

1150 

1151 Example: 

1152 

1153 print 't----t uvw Ex 2 t----' 

1154 print me.uvw('itrf','30deg','40deg','10m') 

1155 #{'m0': {'value': 0.52359877559829882, 'unit': 'rad'}, 

1156 # 'm1': {'value': 0.6981317007977319, 'unit': 'rad'}, 

1157 # 'm2': {'value': 9.9999999999999982, 'unit': 'm'}, 

1158 # 'refer': 'ITRF', 

1159 # 'type': 'uvw'} 

1160 print me.doframe(me.epoch('utc','today')) 

1161 #True 

1162 print me.doframe(me.observatory('ALMA')) 

1163 #True 

1164 print me.doframe(me.direction('mars')) 

1165 #True 

1166 print me.measure(me.uvw('itrf','30deg','40deg','10m'), 'j2000') 

1167 #{'m0': {'value': 0.52321924738347259, 'unit': 'rad'}, 

1168 # 'm1': {'value': 0.69813169995801672, 'unit': 'rad'}, 

1169 # 'm2': {'value': 10.0, 'unit': 'm'}, 

1170 # 'refer': 'J2000', 

1171 # 'type': 'uvw'} 

1172 

1173 -------------------------------------------------------------------------------- 

1174 

1175 """ 

1176 return _measures.measures_uvw(self, *args, **kwargs) 

1177 

1178 

1179 def touvw(self, *args, **kwargs): 

1180 """ 

1181 touvw(self, _v, _dot, _xyz) -> record * 

1182 

1183 

1184 

1185 Summary: 

1186 calculate a uvw measure from a baseline 

1187 

1188 Description: 

1189 

1190 

1191 touvw calculates a uvw measure from a baseline. Note that the 

1192 baseline does not have to be a proper {em baseline}, but can be a 

1193 series of positions (to call positions baselines see 

1194 asbaseline ) for speed reasons: 

1195 operations are linear and can be done on positions, which are 

1196 converted to baseline values at the end (with 

1197 expand ). 

1198 

1199 Whatever the reference code of the baseline, the returned {em uvw} will be 

1200 given in J2000. If the {em dot} argument is given, that variable 

1201 will be filled with a quantity array consisting of the time 

1202 derivative of the uvw (note that only the sidereal rate is taken 

1203 into account; not precession, earth tides and similar variations, 

1204 which are much smaller). If the {em xyz} variable is given, it will 

1205 be filled with the quantity values of the uvw measure. 

1206 

1207 The values of the input baselines can be given as a quantity 

1208 vector per x, y or z value. 

1209 

1210 uvw coordinates are calculated for a certain direction in the sky; 

1211 hence the frame has to contain the direction for the calculation to 

1212 work. Since the baseline and the sky rotate with respect of each 

1213 other, the time should be specified as well. 

1214 

1215 Input Parameters: 

1216 v baseline measure 

1217 

1218 Output Parameters: 

1219 dot uvw-dot (quantity array) 

1220 xyz uvw (quantity array) 

1221 

1222 Example: 

1223 

1224 print 't----t touvw Ex 1 t----' 

1225 print me.doframe(me.observatory('atca')) 

1226 #True 

1227 print me.doframe(me.source('1934-638')) 

1228 #True 

1229 print me.doframe(me.epoch('utc',qa.unit('today'))) 

1230 #True 

1231 b=me.baseline('itrf','10m','20m','30m') 

1232 print me.touvw(b) 

1233 #{'dot': {'unit': 'm/s', 

1234 # 'value': [-0.0011912452908351659, 

1235 # -0.00098731747136827593, 

1236 # -0.00048769097314181744]}, 

1237 # 'return': {'m0': {'value': -0.094777304811312649, 'unit': 'rad'},