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
casacore
this file contains all the compiler specific defines
Definition:
mainpage.dox:28
Generated by
1.8.17