casacore
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
42namespace 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> <src>'</src> is used for arcmin
118// <li> <src>''</src> or <src>"</src> 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
this file contains all the compiler specific defines
Definition: mainpage.dox:28