casa  5.7.0-16
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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 
35 //# Next one at this place
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 
#define casacore
&lt;X11/Intrinsic.h&gt; #defines true, false, casacore::Bool, and String.
Definition: X11Intrinsic.h:42