casa
5.7.0-16
Main Page
Related Pages
Modules
Namespaces
Classes
Files
File List
File Members
All
Classes
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Friends
Macros
Groups
Pages
casa
casacore
casa
Quanta.h
Go to the documentation of this file.
1
//# Quanta.h: a module for units and quantities
2
//# Copyright (C) 1998,1999,2000,2004
3
//# Associated Universities, Inc. Washington DC, USA.
4
//#
5
//# This library is free software; you can redistribute it and/or modify it
6
//# under the terms of the GNU Library General Public License as published by
7
//# the Free Software Foundation; either version 2 of the License, or (at your
8
//# option) any later version.
9
//#
10
//# This library is distributed in the hope that it will be useful, but WITHOUT
11
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12
//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13
//# License for more details.
14
//#
15
//# You should have received a copy of the GNU Library General Public License
16
//# along with this library; if not, write to the Free Software Foundation,
17
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18
//#
19
//# Correspondence concerning AIPS++ should be addressed as follows:
20
//# Internet email: aips2-request@nrao.edu.
21
//# Postal address: AIPS++ Project Office
22
//# National Radio Astronomy Observatory
23
//# 520 Edgemont Road
24
//# Charlottesville, VA 22903-2475 USA
25
//#
26
//# $Id$
27
28
#ifndef CASA_QUANTA_H
29
#define CASA_QUANTA_H
30
31
//# Includes
32
#include <
casacore/casa/aips.h
>
33
34
#include <
casacore/casa/Quanta/Unit.h
>
35
//# Next one at this place
36
#include <
casacore/casa/Quanta/QC.h
>
37
#include <
casacore/casa/Quanta/UnitMap.h
>
38
#include <
casacore/casa/Quanta/Quantum.h
>
39
#include <
casacore/casa/Quanta/QMath.h
>
40
#include <
casacore/casa/Quanta/QLogical.h
>
41
42
namespace
casacore
{
//# NAMESPACE CASACORE - BEGIN
43
44
// <module>
45
//
46
47
// <summary> a module for units and quantities </summary>
48
49
// <use visibility=export>
50
51
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="tUnit tQuantum"
52
// demos="dMUString">
53
// </reviewed>
54
55
// <prerequisite>
56
// </prerequisite>
57
58
// <etymology>
59
// The name Quanta derives from a physical quantity, i.e. a value with
60
// units attached.
61
// </etymology>
62
//
63
// <synopsis>
64
// The Quanta model deals with units and physical quantities
65
// (i.e. values with a unit).
66
// Units are handled in the <a href="#Unit">Unit</a> section
67
// (see <linkto class="Unit">Unit.h</linkto>).
68
// Quantities are handled in the <a href="#Quantum">Quantum</a> section
69
// (see <linkto class="Quantum">Quantum.h</linkto>).
70
// In addition the module contains some more general support classes
71
// (<linkto class=Euler>Euler</linkto> angles,
72
// <linkto class=RotMatrix>rotation matrix</linkto>,
73
// <linkto class=MUString>pointed string</linkto>), formatting for
74
// <linkto class=MVTime>time</linkto> and <linkto class=MVAngle>angle</linkto>
75
// classes and classes containing information for
76
// Measures (<linkto class=MeasValue>MeasValue</linkto> and the derived MV
77
// classes like <linkto class=MVEpoch>MVEpoch</linkto>). See the
78
// <a href="#MeasValue">MeasValue</a> section.
79
//
80
// <h3> Includes</h3>
81
// Including the <src>casa/Quanta.h</src> will take care of all
82
// includes necessary for the handling of pure Units and Quantities.
83
//
84
// <anchor name="Unit"><h3> Physical units </h3></anchor>
85
// Physical units are basically used in quantities
86
// (see <linkto class="Quantum">Quantum</linkto>), i.e.
87
// a value and a dimension. The Unit class, or one of its subsidiaries, will
88
// in general not be called separately. The only reason to make use of these
89
// classes is to generate additional 'tagged' units, i.e. units with a
90
// special name, e.g. 'beam' for a telescope beam, or 'JY', a non-SI name
91
// for Jy.
92
// <h3> Units </h3>
93
// A Unit is in principle specified as a String (or directly as "string"),
94
// and can be defined as either a Unit or a String.
95
// If defined as a Unit, the format of the string will be checked for a
96
// legal definition and relevant information (e.g. scale, dimension type) is
97
// cached in the Unit object, leading to (much) faster use; if defined as a
98
// String, the checking will be postponed
99
// until any use is made of the information in the string.
100
//
101
// A unit is a string of one or more fields separated
102
// by 'space' or '.' (to indicate multiply) or '/' (to indicate divide).
103
// Multiple separators are acted upon (i.e. <src>m//s == m.s</src>).
104
// Separators are acted upon left-to-right (i.e. <src>m/s/A == (m/s)/A</src>;
105
// use () to indicate otherwise (e.g. <src>m/(s/A)</src> )).
106
//
107
// A field is a name, or a unit enclosed in (), optionally followed by an,
108
// optionally signed, decimal constant. E.g. <src>m.(m/s)-2 == m-1.s2</src> )
109
//
110
// Note that a 'space' or '.' before an opening '(' can be omitted.
111
//
112
// A name can consist of case-sensitive letters, '_', ''', ':', '"' and '0'
113
// ('0' not as first character). Digits 1-9 are allowed if preceded with
114
// an '_'. Possible legal names are e.g. Jy, R0, R_1, "_2.
115
// <note role=tip>
116
// <ul>
117
// <li> ' is used for arcmin
118
// <li> '' or " for arcsec
119
// <li> : :: and ::: are used for h, min, s respectively.
120
// </ul>
121
// </note>
122
// <note role=tip> The standard naming conventions for SI units are that they
123
// are all in lowercase, unless derived from a person's name, when they start
124
// with a capital letter. Notable exceptions are some of the astronomical
125
// SI related units (e.g. AU).
126
// </note>
127
// A name can be preceded by a (standard) decimal prefix.
128
//
129
// A name must be defined in a Unit map before it can be used.
130
//
131
// All SI units and some customary units are part of the classes. User
132
// defined names can be added by the UnitMap::putUser() function (see
133
// <linkto class="UnitMap">UnitMap</linkto>). A special set of FITS related
134
// units can be added by the <src>UnitMap::addFITS()</src> function. For
135
// details, see <linkto class="UnitMap">UnitMap</linkto>.
136
//
137
// Example:
138
// <srcblock>
139
// km/s/(Mpc.s)2 is identical to km.s-1.Mpc-2.s-2
140
// </srcblock>
141
// There are 5 name lists in the UnitMap, which are searched in reverse order:
142
// <ol>
143
// <li> Defining units: m, kg, s, A, K, cd, mol, rad, sr, _
144
// <li> SI units: including a.o. g, Jy, AU
145
// <li> Customary units: e.g. lb, hp, ly
146
// <li> User defined units: defined by user (e.g. beam, KPH, KM)
147
// <li> Cached units: for speed in operations
148
// </ol>
149
// All known names can be viewed by running the tUnit test program, or
150
// using the MapUnit::list() routine.
151
//
152
// The definitions that were current on 990915 are given at end of this file
153
//
154
// <note role=caution>
155
// There is a difference between units without a dimension (non-dimensioned
156
// I will call them), and undimensioned units. Non-dimensioned examples are
157
// "", "%"; undimensioned examples: "beam", "pixel".
158
// </note>
159
//
160
// <h3> Working with units </h3>
161
// In general units are not used explicitly, but are embedded in quantities
162
// and coordinates.
163
//
164
// Explicit use of units is only necessary if:
165
// <ol>
166
// <li> a unit string has to be tested for legality (e.g. exist JY?)
167
// <li> a unit string has to be named (e.g. H0 for km/s/Mpc)
168
// <li> some calculation on units has to be performed
169
// (e.g. how many hp.s per eV)
170
// </ol>
171
//
172
// For these cases a Unit can be defined as either a String or a Unit. If
173
// specified as a Unit an automatic check (with exception if illegal) of
174
// the format of the unit string is performed
175
// <srcblock>
176
// Unit a="km/Ms"; String b="Mm/Gs"; //produce 'identical' units a and b
177
// Unit a("KpH"); // will produce exception
178
// String a("KpH"); // will be accepted till some other action
179
// // done on a
180
// // The following will define a unit named 'tag' with a value identical
181
// // to 5 mJy. After this definition tag can be used as any other unit,
182
// // e.g. Unit("Gtag/pc") will be a valid unit string.
183
// UnitMap::putUser("tag",UnitVal(5.,"mJy"),"my own unit name for 5 mJy");
184
// // The following will calculate how many hp.s per eV
185
// Double hpeV = (UnitVal("hp.s")/UnitVal("eV")).getFac();
186
// // maybe after checking for identical dimensions
187
// if ( UnitVal("hp.s") != UnitVal("eV")) { cout << "unexpected" << endl; }
188
// </srcblock>
189
// <note role=tip>
190
// UnitVal has the following special constants to easily check unit
191
// dimensions (note that they can be combined to e.g. generate velocity
192
// as 'UnitVal::LENGTH/UnitVal::TIME')
193
// <ul>
194
// <li> UnitVal::NODIM
195
// <li> UnitVal::LENGTH
196
// <li> UnitVal::MASS
197
// <li> UnitVal::TIME
198
// <li> UnitVal::TEMPERATURE
199
// <li> UnitVal::ANGLE
200
// <li> UnitVal::SOLIDANGLE
201
// <li> UnitVal::MOLAR
202
// <li> UnitVal::CURRENT
203
// <li> UnitVal::INTENSITY
204
// </ul>
205
// </note>
206
//
207
// See the <linkto class="UnitVal">UnitVal</linkto>
208
// for details of calculating with units.
209
// See the <linkto class="UnitMap">UnitMap</linkto>
210
// for the details of defining/viewing named units.
211
//
212
//
213
// <anchor name="Quantum"><h3> Quantums and Quantities </h3></anchor>
214
// A Quantum is a value with a unit. Quantums are templated on their value
215
// type (e.g. <src>Float</src>, <src>Vector<Double></src>). <em>Quantity</em>
216
// is a typedef
217
// for the (probably most common) <src>Quantum<Double></src>.
218
// The basic specification of a Quantum is:
219
// <srcblock>
220
// Quantum<Type> ( Type value, Unit unit); // or: String unit or: "unit"
221
// Quantity( Double value, Unit unit); // or: String unit or: "unit"
222
// </srcblock>
223
//
224
// E.g.
225
// <ul>
226
// <li> <src>Quantity(5.,"m");</src>
227
// <li> <src>Quantum<Double> (5.,"m"); // identical to previous</src>
228
// <li> <src>Vector<Int> a(3); a(3) = 5; Quantum<Vector<Int> >(a,"Jy");</src>
229
// </ul>
230
//
231
// The following list of constructors is available.
232
// <note role=tip>
233
// In the following 'Unit' can be replaced by 'String' (or "string" everywhere.
234
// The only difference being a check for a legitimate unit string being
235
// executed if Unit specified (with exception if error), and a much faster
236
// execution of the Unit is used repeatedly.
237
// <src>Quantum<Type></src> can, if Type equals Double, be replaced with
238
// <src>Quantity</src>
239
// </note>
240
// <ul>
241
// <li> <src>Quantum<Type>() value 0 generated</src>
242
// <li> <src>Quantum<Type>( Quantum<Type>) copy constructor</src>
243
// <li> <src>Quantum<Type>( Type factor) value factor generated</src>
244
// <li> <src>Quantum<Type>( Type factor, Unit unit) specified quantity</src>
245
// <li> <src>Quantum<Type>( Type factor, Quantum<any> quant) specified
246
// factor,
247
// the unit from the quant</src>
248
// </ul>
249
//
250
// The following operators and functions are defined on Quantums. They are,
251
// of course, only available if the template Type supports them (e.g. / will
252
// not be defined for a <src>Quantum<String></src> (whatever that may mean)).
253
// <ul>
254
// <li> <src>= assignment of identical <type></src>
255
// <li> <src>* *= multiply two Quantums of same <type></src>
256
// <li> <src>/ /= divide two Quantums of same <type></src>
257
// <li> <src>+ += add two Quantums of same <type> and same unit dimensions</src>
258
// (else exception)
259
// <li> <src>- -= subtract two Quantums of same <type> and same unit dimensions</src>
260
// (else exception)
261
// <li> - negate Quantum
262
// <li> <src>== != compare unit dimensions and value of same <type></src>.
263
// They will be unequal if the unit dimensions do not
264
// match or the values (converted to common
265
// base units) are unequal
266
// <li> <src>< > compare unit dimensions of same <type></src>.
267
// Exception if no match,
268
// else compare the values
269
// <li> <src><= >=</src> ibid
270
// <li> pow(Quantum, Int) raise to an (integer) power
271
// <li> abs(Quant) take absolute value
272
// <li> ceil, floor(Quant)
273
// <li> sin, cos, tan(Quant) correct units used
274
// <li> asin, acos, atan(Quant), atan2(Q,Q) correct units used
275
// <li> near, nearAbs
276
// </ul>
277
//
278
//
279
// Quanta can be converted to other units by the following set of member
280
// functions:
281
// <ul>
282
// <li> convert() will convert the quantum to canonical units.
283
// E.g. given myval=Quantity(5.,"Jy"),
284
// myval.convert() will make myval have the value
285
// Quantity(5.e-26,"kg.s-2")
286
// <li> get() will return the quantum converted to
287
// canonical units
288
// <li> convert(Unit unit) will convert the quantum to the
289
// specified unit with any remaining dimensions
290
// expressed in canonical units. E.g given
291
// myval as above, myval.convert("W/cm") will
292
// make myval Quantity(5.e-28,"W/cm.m-1.s")
293
// <li> get(Unit unit) will return the quantum converted to unit
294
// <li> <src>convert(Quantum<any> quant)</src> will convert the quantum
295
// to the units of the specified quant with the
296
// same conversion rules as the previous one
297
// <li> <src>get(Quantum<any> quant) will return the converted quantum</src>
298
// </ul>
299
// Quanta can be checked for having the correct unit dimensions (e.g. before
300
// addition or comparing) by the following two member functions, which will
301
// return a Bool value or raise an exception:
302
// <ul>
303
// <li> <src>Bool isConform(Unit)</src>
304
// <li> <src>Bool isConform(Quantum<any>)</src>
305
// <li> <src>Bool check(UnitVal)</src>
306
// <li> <src> void assure(UnitVal)</src>
307
// </ul>
308
//
309
// The value and units of a quantum can be set or retrieved separately by the
310
// following member functions:
311
// <ul>
312
// <li> <src>Type getValue()</src> return the value (as Type) of the quantum
313
// <li> <src>Type getValue(Unit)</src> return the value in specified units
314
// <li> <src>Type getBaseValue()</src> return the value in canonical units
315
// <li> <src>String getUnit()</src> return the units of the quantum
316
// <li> <src>void setValue(Type val)</src> replace the value of the quantum with val,
317
// leaving the units the same
318
// <li> <src>void scale(Type)</src> scale the value (leaving units same) by
319
// multiplying with the specified value
320
// <li> <src>void setUnit(Unit)</src> replace the units of the quantum, leaving
321
// the value the same.
322
// <li> <src>void setUnit(Quantum<any>)</src> ibid
323
// </ul>
324
//
325
// The output operator ('<<') will produce the value of the quantum and its
326
// units. Given <src>Quantity myval(5.,"mJy");</src>,
327
// <src>cout << myval;</src> will produce:
328
// "5.0 mJy"; while <src>cout << myval.get("yW/m2")</src> will produce:
329
// ".00005 yW/m2.s"
330
//
331
//
332
// <h3> QC class of constant quantities </h3>
333
// In parallel with the 'C' class of undimensioned constants, the QC class
334
// contains dimensioned constants.
335
// On 960509 the following were defined:
336
// <ul>
337
// <li> <src>Quantum<Double> c; // vel of light</src>
338
// <li> <src>Quantum<Double> G; // Gravitational constant</src>
339
// <li> <src>Quantum<Double> h; // Planck</src>
340
// <li> <src>Quantum<Double> HI; // Frequency HI line</src>
341
// <li> <src>Quantum<Double> R; // Gas constant</src>
342
// <li> <src>Quantum<Double> NA; // Avogadro</src>
343
// <li> <src>Quantum<Double> e; // electron charge</src>
344
// <li> <src>Quantum<Double> mp; // proton mass</src>
345
// <li> <src>Quantum<Double> mp_me; // mp/me</src>
346
// <li> <src>Quantum<Double> mu0; // permeability vacuum</src>
347
// <li> <src>Quantum<Double> epsilon0; // permittivity vacuum</src>
348
// <li> <src>Quantum<Double> k; // Boltzmann</src>
349
// <li> <src>Quantum<Double> F; // Faraday</src>
350
// <li> <src>Quantum<Double> me; // mass electron</src>
351
// <li> <src>Quantum<Double> re; // radius electron</src>
352
// <li> <src>Quantum<Double> a0; // Bohr's radius</src>
353
// <li> <src>Quantum<Double> R0; // Solar radius</src>
354
// <li> <src>Quantum<Double> k2; // IAU Gaussian grav. const **2</src>
355
// </ul>
356
//
357
// <p>
358
// <anchor name="MeasValue"><h3> Values for Measures </h3></anchor>
359
// The MeasValue class derivatives are all named <em>MVmeasure</em>, e.g.
360
// <em>MVFrequency</em>, and represent the internal representation of the
361
// specific measure class. There main use is for the Measures module,
362
// but they can be used alone, e.g. for the conversion to formatted times,
363
// or the conversion of frequencies from say wavelength to frequency.
364
// They all have at least the following constructors:
365
// <srcblock>
366
// MV()
367
// MV(MV)
368
// MV(Double)
369
// MV(Vector<Double>)
370
// MV(Quantity)
371
// MV(Vector<Quantity>)
372
// MV(Quantum<Vector<Double> >)
373
// </srcblock>
374
// But most have also constructors like:
375
// <srcblock>
376
// MV(Double, Double)
377
// MV(Quantity, Quantity)
378
// </srcblock>
379
// The actual interpretation is class dependent: see the individual MV classes
380
// like <linkto class=MVEpoch>MVEpoch</linkto>,
381
// <linkto class=MVDirection>MVDirection</linkto>,
382
// <linkto class=MVPosition>MVPosition</linkto>,
383
// <linkto class=MVFrequency>MVFrequency</linkto>,
384
// <linkto class=MVDouble>MVDouble</linkto>,
385
// <linkto class=MVRadialVelocity>MVRadialVelocity</linkto>.
386
// <linkto class=MVBaseline>MVBaseline</linkto>,
387
// <linkto class=MVuvw>MVuvw</linkto>,
388
// <linkto class=MVEarthMagnetic>MVEarthMagnetic</linkto>,
389
// A few examples:
390
// <srcblock>
391
// MVEpoch(12345, 0.1e-20) will create one epoch (MJD12345.0), but preserving
392
// the precision of all information
393
// MVDirection(Quantity(20,"deg"), Quantity(-10,"'")) will create a direction
394
// with an RA of 20 degree, and a DEC of -10 arcmin
395
// MVFrequency(Quantity(5,"keV")) will create a frequency corresponding to
396
// the specified energy.
397
// </srcblock>
398
// All MVs have the <src>+=, -=, ==, !=, << </src>operators, and <src>near()</src>,
399
// <src>nearAbs()</src>, <src>print()</src> and <src>adjust()</src>
400
// and <src>readjust()</src> (which in general
401
// normalise to a value of 1 (e.g. MVDirection), or recalculates high
402
// precision values (e.g. MVEpoch) functions.<br>
403
// Information can be viewed with many <em>get</em> functions. In most cases
404
// getValue() will return the internal value as either Double or
405
// Vector<Double>; get() will return the same, or converted values (e.g.
406
// a vector of length, angle, angle for MVPosition; while special
407
// one like getAngle() or getAngle(unit), getTime() etc will return Quantums
408
// (with optional conversion to specified units).<br>
409
// In general the Measure classes can be used without worrying about the
410
// MeasValues, since most Measure constructors have enough flexibility (and
411
// their own get()'s) to be able to use them independently).<br>
412
// Special cases are <linkto class=MVAngle>MVAngle</linkto> and
413
// <linkto class=MVTime>MVTime</linkto>, which can do special formatting for
414
// time and angles (in earlier documentation they were called HMS etc.).
415
// <p>
416
417
// </synopsis>
418
//
419
// <motivation>
420
// The Quanta model originated to handle physical quantities independent of their
421
// units.
422
// Units were introduced in the described way to be able to handle any
423
// possible physical unit.
424
// </motivation>
425
//
426
// <todo asof="1998/07/22">
427
// <li> inlining
428
// <li> look at the problem of rad*rad (which is, in general, not sr)
429
// </todo>
430
//
431
// <example>
432
// <h3> Known units on 960509 </h3>
433
// <srcblock>
434
// // UnitMap::list() will produce the following list:
435
//List all defined symbols
436
//
437
//Prefix table (20):
438
// E (exa) 1e+18
439
// G (giga) 1000000000
440
// M (mega) 1000000
441
// P (peta) 1e+15
442
// T (tera) 1e+12
443
// Y (yotta) 1e+24
444
// Z (zetta) 1e+21
445
// a (atto) 1e-18
446
// c (centi) 0.01
447
// d (deci) 0.1
448
// da (deka) 10
449
// f (femto) 1e-15
450
// h (hecto) 100
451
// k (kilo) 1000
452
// m (milli) 0.001
453
// n (nano) 1e-09
454
// p (pico) 1e-12
455
// u (micro) 1e-06
456
// y (yocto) 1e-24
457
// z (zepto) 1e-21
458
//Defining unit table (10):
459
// A (ampere) 1 A
460
// K (kelvin) 1 K
461
// _ (undimensioned) 1 _
462
// cd (candela) 1 cd
463
// kg (kilogram) 1 kg
464
// m (metre) 1 m
465
// mol (mole) 1 mol
466
// rad (radian) 1 rad
467
// s (second) 1 s
468
// sr (steradian) 1 sr
469
//SI unit table (50):
470
// $ (currency) 1 _
471
// % (percent) 0.01
472
// %% (permille) 0.001
473
// A (ampere) 1 A
474
// AE (astronomical unit) 149597870659 m
475
// AU (astronomical unit) 149597870659 m
476
// Bq (becquerel) 1 s-1
477
// C (coulomb) 1 s.A
478
// F (farad) 1 m-2.kg-1.s4.A2
479
// Gy (gray) 1 m2.s-2
480
// H (henry) 1 m2.kg.s-2.A-2
481
// Hz (hertz) 1 s-1
482
// J (joule) 1 m2.kg.s-2
483
// Jy (jansky) 1e-26 kg.s-2
484
// K (kelvin) 1 K
485
// L (litre) 0.001 m3
486
// M0 (solar mass) 1.98891944407e+30 kg
487
// N (newton) 1 m.kg.s-2
488
// Ohm (ohm) 1 m2.kg.s-3.A-2
489
// Pa (pascal) 1 m-1.kg.s-2
490
// S (siemens) 1 m-2.kg-1.s3.A2
491
// S0 (solar mass) 1.98891944407e+30 kg
492
// Sv (sievert) 1 m2.s-2
493
// T (tesla) 1 kg.s-2.A-1
494
// UA (astronomical unit) 149597870659 m
495
// V (volt) 1 m2.kg.s-3.A-1
496
// W (watt) 1 m2.kg.s-3
497
// Wb (weber) 1 m2.kg.s-2.A-1
498
// _ (undimensioned) 1 _
499
// a (year) 31557600 s
500
// arcmin (arcmin) 0.000290888208666 rad
501
// arcsec (arcsec) 4.8481368111e-06 rad
502
// as (arcsec) 4.8481368111e-06 rad
503
// cd (candela) 1 cd
504
// cy (century) 3155760000 s
505
// d (day) 86400 s
506
// deg (degree) 0.0174532925199 rad
507
// g (gram) 0.001 kg
508
// h (hour) 3600 s
509
// l (litre) 0.001 m3
510
// lm (lumen) 1 cd.sr
511
// lx (lux) 1 m-2.cd.sr
512
// m (metre) 1 m
513
// min (minute) 60 s
514
// mol (mole) 1 mol
515
// pc (parsec) 3.08567758065e+16 m
516
// rad (radian) 1 rad
517
// s (second) 1 s
518
// sr (steradian) 1 sr
519
// t (tonne) 1000 kg
520
//Customary unit table (74):
521
// " (arcsec) 4.8481368111e-06 rad
522
// "_2 (square arcsec) 2.35044305391e-11 sr
523
// ' (arcmin) 0.000290888208666 rad
524
// '' (arcsec) 4.8481368111e-06 rad
525
// ''_2 (square arcsec) 2.35044305391e-11 sr
526
// '_2 (square arcmin) 8.46159499408e-08 sr
527
// : (hour) 3600 s
528
// :: (minute) 60 s
529
// ::: (second) 1 s
530
// Ah (ampere hour) 3600 s.A
531
// Angstrom (angstrom) 1e-10 m
532
// Btu (British thermal unit (Int)) 1055.056 m2.kg.s-2
533
// CM (metric carat) 0.0002 kg
534
// Cal (large calorie (Int)) 4186.8 m2.kg.s-2
535
// FU (flux unit) 1e-26 kg.s-2
536
// G (gauss) 0.0001 kg.s-2.A-1
537
// Gal (gal) 0.01 m.s-2
538
// Gb (gilbert) 0.795774715459 A
539
// Mx (maxwell) 1e-08 m2.kg.s-2.A-1
540
// Oe (oersted) 79.5774715459 m-1.A
541
// R (mile) 0.000258 kg-1.s.A
542
// St (stokes) 0.0001 m2.s-1
543
// Torr (torr) 133.322368421 m-1.kg.s-2
544
// USfl_oz (fluid ounce (US)) 2.95735295625e-05 m3
545
// USgal (gallon (US)) 0.003785411784 m3
546
// WU (WSRT flux unit) 5e-29 kg.s-2
547
// abA (abampere) 10 A
548
// abC (abcoulomb) 10 s.A
549
// abF (abfarad) 1000000000 m-2.kg-1.s4.A2
550
// abH (abhenry) 1e-09 m2.kg.s-2.A-2
551
// abOhm (abohm) 1e-09 m2.kg.s-3.A-2
552
// abV (abvolt) 1e-08 m2.kg.s-3.A-1
553
// ac (acre) 4046.8564224 m2
554
// arcmin_2 (square arcmin) 8.46159499408e-08 sr
555
// arcsec_2 (square arcsec) 2.35044305391e-11 sr
556
// ata (technical atmosphere) 98066.5 m-1.kg.s-2
557
// atm (standard atmosphere) 101325 m-1.kg.s-2
558
// bar (bar) 100000 m-1.kg.s-2
559
// beam (undefined beam area) 1 _
560
// cal (calorie (Int)) 4.1868 m2.kg.s-2
561
// cwt (hundredweight) 50.80234544 kg
562
// deg_2 (square degree) 0.000304617419787 sr
563
// dyn (dyne) 1e-05 m.kg.s-2
564
// eV (electron volt) 1.60217733e-19 m2.kg.s-2
565
// erg (erg) 1e-07 m2.kg.s-2
566
// fl_oz (fluid ounce (Imp)) 2.84130488996e-05 m3
567
// ft (foot) 0.3048 m
568
// fu (flux unit) 1e-26 kg.s-2
569
// fur (furlong) 201.168 m
570
// gal (gallon (Imp)) 0.00454608782394 m3
571
// ha (hectare) 10000 m2
572
// hp (horsepower) 745.7 m2.kg.s-3
573
// in (inch) 0.0254 m
574
// kn (knot (Imp)) 0.514773333333 m.s-1
575
// lb (pound (avoirdupois)) 0.45359237 kg
576
// ly (light year) 9.46073047e+15 m
577
// mHg (metre of mercury) 133322.387415 m-1.kg.s-2
578
// mile (mile) 1609.344 m
579
// n_mile (nautical mile (Imp)) 1853.184 m
580
// oz (ounce (avoirdupois)) 0.028349523125 kg
581
// pixel (pixel) 1 _
582
// sb (stilb) 10000 m-2.cd
583
// sq_arcmin (square arcmin) 8.46159499408e-08 sr
584
// sq_arcsec (square arcsec) 2.35044305391e-11 sr
585
// sq_deg (square degree) 0.000304617419787 sr
586
// statA (statampere) 3.33564095198e-10 A
587
// statC (statcoulomb) 3.33564095198e-10 s.A
588
// statF (statfarad) 1.11188031733e-12 m-2.kg-1.s4.A2
589
// statH (stathenry) 899377374000 m2.kg.s-2.A-2
590
// statOhm (statohm) 899377374000 m2.kg.s-3.A-2
591
// statV (statvolt) 299.792458 m2.kg.s-3.A-1
592
// debye (electric dipole moment) 10-18 statC.cm
593
// u (atomic mass unit) 1.661e-27 kg
594
// yd (yard) 0.9144 m
595
// yr (year) 31557600 s
596
// </srcblock>
597
//
598
// </example>
599
// </module>
600
601
//# Dummy class definition for extractor
602
//# class Quanta {};
603
604
605
}
//# NAMESPACE CASACORE - END
606
607
#endif
608
609
610
Quantum.h
aips.h
QMath.h
QLogical.h
UnitMap.h
Unit.h
QC.h
casacore
#define casacore
<X11/Intrinsic.h> #defines true, false, casacore::Bool, and String.
Definition:
X11Intrinsic.h:42
Generated on Sun Sep 1 2019 23:32:13 for casa by
1.8.5