Loading...
Searching...
No Matches
Quanta.h
Go to the documentation of this file.
//# Quanta.h: a module for units and quantities
//# Copyright (C) 1998,1999,2000,2004
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//# Internet email: casa-feedback@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
#ifndef CASA_QUANTA_H
#define CASA_QUANTA_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/casa/Quanta/Unit.h>
//# Next one at this place
#include <casacore/casa/Quanta/QC.h>
#include <casacore/casa/Quanta/UnitMap.h>
#include <casacore/casa/Quanta/Quantum.h>
#include <casacore/casa/Quanta/QMath.h>
#include <casacore/casa/Quanta/QLogical.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
// <module>
//
// <summary> a module for units and quantities </summary>
// <use visibility=export>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="tUnit tQuantum"
// demos="dMUString">
// </reviewed>
// <prerequisite>
// </prerequisite>
// <etymology>
// The name Quanta derives from a physical quantity, i.e. a value with
// units attached.
// </etymology>
//
// <synopsis>
// The Quanta model deals with units and physical quantities
// (i.e. values with a unit).
// Units are handled in the <a href="#Unit">Unit</a> section
// (see <linkto class="Unit">Unit.h</linkto>).
// Quantities are handled in the <a href="#Quantum">Quantum</a> section
// (see <linkto class="Quantum">Quantum.h</linkto>).
// In addition the module contains some more general support classes
// (<linkto class=Euler>Euler</linkto> angles,
// <linkto class=RotMatrix>rotation matrix</linkto>,
// <linkto class=MUString>pointed string</linkto>), formatting for
// <linkto class=MVTime>time</linkto> and <linkto class=MVAngle>angle</linkto>
// classes and classes containing information for
// Measures (<linkto class=MeasValue>MeasValue</linkto> and the derived MV
// classes like <linkto class=MVEpoch>MVEpoch</linkto>). See the
// <a href="#MeasValue">MeasValue</a> section.
//
// <h3> Includes</h3>
// Including the <src>casa/Quanta.h</src> will take care of all
// includes necessary for the handling of pure Units and Quantities.
//
// <anchor name="Unit"><h3> Physical units </h3></anchor>
// Physical units are basically used in quantities
// (see <linkto class="Quantum">Quantum</linkto>), i.e.
// a value and a dimension. The Unit class, or one of its subsidiaries, will
// in general not be called separately. The only reason to make use of these
// classes is to generate additional 'tagged' units, i.e. units with a
// special name, e.g. 'beam' for a telescope beam, or 'JY', a non-SI name
// for Jy.
// <h3> Units </h3>
// A Unit is in principle specified as a String (or directly as "string"),
// and can be defined as either a Unit or a String.
// If defined as a Unit, the format of the string will be checked for a
// legal definition and relevant information (e.g. scale, dimension type) is
// cached in the Unit object, leading to (much) faster use; if defined as a
// String, the checking will be postponed
// until any use is made of the information in the string.
//
// A unit is a string of one or more fields separated
// by 'space' or '.' (to indicate multiply) or '/' (to indicate divide).
// Multiple separators are acted upon (i.e. <src>m//s == m.s</src>).
// Separators are acted upon left-to-right (i.e. <src>m/s/A == (m/s)/A</src>;
// use () to indicate otherwise (e.g. <src>m/(s/A)</src> )).
//
// A field is a name, or a unit enclosed in (), optionally followed by an,
// optionally signed, decimal constant. E.g. <src>m.(m/s)-2 == m-1.s2</src> )
//
// Note that a 'space' or '.' before an opening '(' can be omitted.
//
// A name can consist of case-sensitive letters, '_', ''', ':', '"' and '0'
// ('0' not as first character). Digits 1-9 are allowed if preceded with
// an '_'. Possible legal names are e.g. Jy, R0, R_1, "_2.
// <note role=tip>
// <ul>
// <li> <src>'</src> is used for arcmin
// <li> <src>''</src> or <src>"</src> for arcsec
// <li> : :: and ::: are used for h, min, s respectively.
// </ul>
// </note>
// <note role=tip> The standard naming conventions for SI units are that they
// are all in lowercase, unless derived from a person's name, when they start
// with a capital letter. Notable exceptions are some of the astronomical
// SI related units (e.g. AU).
// </note>
// A name can be preceded by a (standard) decimal prefix.
//
// A name must be defined in a Unit map before it can be used.
//
// All SI units and some customary units are part of the classes. User
// defined names can be added by the UnitMap::putUser() function (see
// <linkto class="UnitMap">UnitMap</linkto>). A special set of FITS related
// units can be added by the <src>UnitMap::addFITS()</src> function. For
// details, see <linkto class="UnitMap">UnitMap</linkto>.
//
// Example:
// <srcblock>
// km/s/(Mpc.s)2 is identical to km.s-1.Mpc-2.s-2
// </srcblock>
// There are 5 name lists in the UnitMap, which are searched in reverse order:
// <ol>
// <li> Defining units: m, kg, s, A, K, cd, mol, rad, sr, _
// <li> SI units: including a.o. g, Jy, AU
// <li> Customary units: e.g. lb, hp, ly
// <li> User defined units: defined by user (e.g. beam, KPH, KM)
// <li> Cached units: for speed in operations
// </ol>
// All known names can be viewed by running the tUnit test program, or
// using the MapUnit::list() routine.
//
// The definitions that were current on 990915 are given at end of this file
//
// <note role=caution>
// There is a difference between units without a dimension (non-dimensioned
// I will call them), and undimensioned units. Non-dimensioned examples are
// "", "%"; undimensioned examples: "beam", "pixel".
// </note>
//
// <h3> Working with units </h3>
// In general units are not used explicitly, but are embedded in quantities
// and coordinates.
//
// Explicit use of units is only necessary if:
// <ol>
// <li> a unit string has to be tested for legality (e.g. exist JY?)
// <li> a unit string has to be named (e.g. H0 for km/s/Mpc)
// <li> some calculation on units has to be performed
// (e.g. how many hp.s per eV)
// </ol>
//
// For these cases a Unit can be defined as either a String or a Unit. If
// specified as a Unit an automatic check (with exception if illegal) of
// the format of the unit string is performed
// <srcblock>
// Unit a="km/Ms"; String b="Mm/Gs"; //produce 'identical' units a and b
// Unit a("KpH"); // will produce exception
// String a("KpH"); // will be accepted till some other action
// // done on a
// // The following will define a unit named 'tag' with a value identical
// // to 5 mJy. After this definition tag can be used as any other unit,
// // e.g. Unit("Gtag/pc") will be a valid unit string.
// UnitMap::putUser("tag",UnitVal(5.,"mJy"),"my own unit name for 5 mJy");
// // The following will calculate how many hp.s per eV
// Double hpeV = (UnitVal("hp.s")/UnitVal("eV")).getFac();
// // maybe after checking for identical dimensions
// if ( UnitVal("hp.s") != UnitVal("eV")) { cout << "unexpected" << endl; }
// </srcblock>
// <note role=tip>
// UnitVal has the following special constants to easily check unit
// dimensions (note that they can be combined to e.g. generate velocity
// as 'UnitVal::LENGTH/UnitVal::TIME')
// <ul>
// <li> UnitVal::NODIM
// <li> UnitVal::LENGTH
// <li> UnitVal::MASS
// <li> UnitVal::TIME
// <li> UnitVal::TEMPERATURE
// <li> UnitVal::ANGLE
// <li> UnitVal::SOLIDANGLE
// <li> UnitVal::MOLAR
// <li> UnitVal::CURRENT
// <li> UnitVal::INTENSITY
// </ul>
// </note>
//
// See the <linkto class="UnitVal">UnitVal</linkto>
// for details of calculating with units.
// See the <linkto class="UnitMap">UnitMap</linkto>
// for the details of defining/viewing named units.
//
//
// <anchor name="Quantum"><h3> Quantums and Quantities </h3></anchor>
// A Quantum is a value with a unit. Quantums are templated on their value
// type (e.g. <src>Float</src>, <src>Vector<Double></src>). <em>Quantity</em>
// is a typedef
// for the (probably most common) <src>Quantum<Double></src>.
// The basic specification of a Quantum is:
// <srcblock>
// Quantum<Type> ( Type value, Unit unit); // or: String unit or: "unit"
// Quantity( Double value, Unit unit); // or: String unit or: "unit"
// </srcblock>
//
// E.g.
// <ul>
// <li> <src>Quantity(5.,"m");</src>
// <li> <src>Quantum<Double> (5.,"m"); // identical to previous</src>
// <li> <src>Vector<Int> a(3); a(3) = 5; Quantum<Vector<Int> >(a,"Jy");</src>
// </ul>
//
// The following list of constructors is available.
// <note role=tip>
// In the following 'Unit' can be replaced by 'String' (or "string" everywhere.
// The only difference being a check for a legitimate unit string being
// executed if Unit specified (with exception if error), and a much faster
// execution of the Unit is used repeatedly.
// <src>Quantum<Type></src> can, if Type equals Double, be replaced with
// <src>Quantity</src>
// </note>
// <ul>
// <li> <src>Quantum<Type>() value 0 generated</src>
// <li> <src>Quantum<Type>( Quantum<Type>) copy constructor</src>
// <li> <src>Quantum<Type>( Type factor) value factor generated</src>
// <li> <src>Quantum<Type>( Type factor, Unit unit) specified quantity</src>
// <li> <src>Quantum<Type>( Type factor, Quantum<any> quant) specified
// factor,
// the unit from the quant</src>
// </ul>
//
// The following operators and functions are defined on Quantums. They are,
// of course, only available if the template Type supports them (e.g. / will
// not be defined for a <src>Quantum<String></src> (whatever that may mean)).
// <ul>
// <li> <src>= assignment of identical <type></src>
// <li> <src>* *= multiply two Quantums of same <type></src>
// <li> <src>/ /= divide two Quantums of same <type></src>
// <li> <src>+ += add two Quantums of same <type> and same unit dimensions</src>
// (else exception)
// <li> <src>- -= subtract two Quantums of same <type> and same unit dimensions</src>
// (else exception)
// <li> - negate Quantum
// <li> <src>== != compare unit dimensions and value of same <type></src>.
// They will be unequal if the unit dimensions do not
// match or the values (converted to common
// base units) are unequal
// <li> <src>< > compare unit dimensions of same <type></src>.
// Exception if no match,
// else compare the values
// <li> <src><= >=</src> ibid
// <li> pow(Quantum, Int) raise to an (integer) power
// <li> abs(Quant) take absolute value
// <li> ceil, floor(Quant)
// <li> sin, cos, tan(Quant) correct units used
// <li> asin, acos, atan(Quant), atan2(Q,Q) correct units used
// <li> near, nearAbs
// </ul>
//
//
// Quanta can be converted to other units by the following set of member
// functions:
// <ul>
// <li> convert() will convert the quantum to canonical units.
// E.g. given myval=Quantity(5.,"Jy"),
// myval.convert() will make myval have the value
// Quantity(5.e-26,"kg.s-2")
// <li> get() will return the quantum converted to
// canonical units
// <li> convert(Unit unit) will convert the quantum to the
// specified unit with any remaining dimensions
// expressed in canonical units. E.g given
// myval as above, myval.convert("W/cm") will
// make myval Quantity(5.e-28,"W/cm.m-1.s")
// <li> get(Unit unit) will return the quantum converted to unit
// <li> <src>convert(Quantum<any> quant)</src> will convert the quantum
// to the units of the specified quant with the
// same conversion rules as the previous one
// <li> <src>get(Quantum<any> quant) will return the converted quantum</src>
// </ul>
// Quanta can be checked for having the correct unit dimensions (e.g. before
// addition or comparing) by the following two member functions, which will
// return a Bool value or raise an exception:
// <ul>
// <li> <src>Bool isConform(Unit)</src>
// <li> <src>Bool isConform(Quantum<any>)</src>
// <li> <src>Bool check(UnitVal)</src>
// <li> <src> void assure(UnitVal)</src>
// </ul>
//
// The value and units of a quantum can be set or retrieved separately by the
// following member functions:
// <ul>
// <li> <src>Type getValue()</src> return the value (as Type) of the quantum
// <li> <src>Type getValue(Unit)</src> return the value in specified units
// <li> <src>Type getBaseValue()</src> return the value in canonical units
// <li> <src>String getUnit()</src> return the units of the quantum
// <li> <src>void setValue(Type val)</src> replace the value of the quantum with val,
// leaving the units the same
// <li> <src>void scale(Type)</src> scale the value (leaving units same) by
// multiplying with the specified value
// <li> <src>void setUnit(Unit)</src> replace the units of the quantum, leaving
// the value the same.
// <li> <src>void setUnit(Quantum<any>)</src> ibid
// </ul>
//
// The output operator ('<<') will produce the value of the quantum and its
// units. Given <src>Quantity myval(5.,"mJy");</src>,
// <src>cout << myval;</src> will produce:
// "5.0 mJy"; while <src>cout << myval.get("yW/m2")</src> will produce:
// ".00005 yW/m2.s"
//
//
// <h3> QC class of constant quantities </h3>
// In parallel with the 'C' class of undimensioned constants, the QC class
// contains dimensioned constants.
// On 960509 the following were defined:
// <ul>
// <li> <src>Quantum<Double> c; // vel of light</src>
// <li> <src>Quantum<Double> G; // Gravitational constant</src>
// <li> <src>Quantum<Double> h; // Planck</src>
// <li> <src>Quantum<Double> HI; // Frequency HI line</src>
// <li> <src>Quantum<Double> R; // Gas constant</src>
// <li> <src>Quantum<Double> NA; // Avogadro</src>
// <li> <src>Quantum<Double> e; // electron charge</src>
// <li> <src>Quantum<Double> mp; // proton mass</src>
// <li> <src>Quantum<Double> mp_me; // mp/me</src>
// <li> <src>Quantum<Double> mu0; // permeability vacuum</src>
// <li> <src>Quantum<Double> epsilon0; // permittivity vacuum</src>
// <li> <src>Quantum<Double> k; // Boltzmann</src>
// <li> <src>Quantum<Double> F; // Faraday</src>
// <li> <src>Quantum<Double> me; // mass electron</src>
// <li> <src>Quantum<Double> re; // radius electron</src>
// <li> <src>Quantum<Double> a0; // Bohr's radius</src>
// <li> <src>Quantum<Double> R0; // Solar radius</src>
// <li> <src>Quantum<Double> k2; // IAU Gaussian grav. const **2</src>
// </ul>
//
// <p>
// <anchor name="MeasValue"><h3> Values for Measures </h3></anchor>
// The MeasValue class derivatives are all named <em>MVmeasure</em>, e.g.
// <em>MVFrequency</em>, and represent the internal representation of the
// specific measure class. There main use is for the Measures module,
// but they can be used alone, e.g. for the conversion to formatted times,
// or the conversion of frequencies from say wavelength to frequency.
// They all have at least the following constructors:
// <srcblock>
// MV()
// MV(MV)
// MV(Double)
// MV(Vector<Double>)
// MV(Quantity)
// MV(Vector<Quantity>)
// MV(Quantum<Vector<Double> >)
// </srcblock>
// But most have also constructors like:
// <srcblock>
// MV(Double, Double)
// MV(Quantity, Quantity)
// </srcblock>
// The actual interpretation is class dependent: see the individual MV classes
// like <linkto class=MVEpoch>MVEpoch</linkto>,
// <linkto class=MVDirection>MVDirection</linkto>,
// <linkto class=MVPosition>MVPosition</linkto>,
// <linkto class=MVFrequency>MVFrequency</linkto>,
// <linkto class=MVDouble>MVDouble</linkto>,
// <linkto class=MVRadialVelocity>MVRadialVelocity</linkto>.
// <linkto class=MVBaseline>MVBaseline</linkto>,
// <linkto class=MVuvw>MVuvw</linkto>,
// <linkto class=MVEarthMagnetic>MVEarthMagnetic</linkto>,
// A few examples:
// <srcblock>
// MVEpoch(12345, 0.1e-20) will create one epoch (MJD12345.0), but preserving
// the precision of all information
// MVDirection(Quantity(20,"deg"), Quantity(-10,"'")) will create a direction
// with an RA of 20 degree, and a DEC of -10 arcmin
// MVFrequency(Quantity(5,"keV")) will create a frequency corresponding to
// the specified energy.
// </srcblock>
// All MVs have the <src>+=, -=, ==, !=, << </src>operators, and <src>near()</src>,
// <src>nearAbs()</src>, <src>print()</src> and <src>adjust()</src>
// and <src>readjust()</src> (which in general
// normalise to a value of 1 (e.g. MVDirection), or recalculates high
// precision values (e.g. MVEpoch) functions.<br>
// Information can be viewed with many <em>get</em> functions. In most cases
// getValue() will return the internal value as either Double or
// Vector<Double>; get() will return the same, or converted values (e.g.
// a vector of length, angle, angle for MVPosition; while special
// one like getAngle() or getAngle(unit), getTime() etc will return Quantums
// (with optional conversion to specified units).<br>
// In general the Measure classes can be used without worrying about the
// MeasValues, since most Measure constructors have enough flexibility (and
// their own get()'s) to be able to use them independently).<br>
// Special cases are <linkto class=MVAngle>MVAngle</linkto> and
// <linkto class=MVTime>MVTime</linkto>, which can do special formatting for
// time and angles (in earlier documentation they were called HMS etc.).
// <p>
// </synopsis>
//
// <motivation>
// The Quanta model originated to handle physical quantities independent of their
// units.
// Units were introduced in the described way to be able to handle any
// possible physical unit.
// </motivation>
//
// <todo asof="1998/07/22">
// <li> inlining
// <li> look at the problem of rad*rad (which is, in general, not sr)
// </todo>
//
// <example>
// <h3> Known units on 960509 </h3>
// <srcblock>
// // UnitMap::list() will produce the following list:
//List all defined symbols
//
//Prefix table (20):
// E (exa) 1e+18
// G (giga) 1000000000
// M (mega) 1000000
// P (peta) 1e+15
// T (tera) 1e+12
// Y (yotta) 1e+24
// Z (zetta) 1e+21
// a (atto) 1e-18
// c (centi) 0.01
// d (deci) 0.1
// da (deka) 10
// f (femto) 1e-15
// h (hecto) 100
// k (kilo) 1000
// m (milli) 0.001
// n (nano) 1e-09
// p (pico) 1e-12
// u (micro) 1e-06
// y (yocto) 1e-24
// z (zepto) 1e-21
//Defining unit table (10):
// A (ampere) 1 A
// K (kelvin) 1 K
// _ (undimensioned) 1 _
// cd (candela) 1 cd
// kg (kilogram) 1 kg
// m (metre) 1 m
// mol (mole) 1 mol
// rad (radian) 1 rad
// s (second) 1 s
// sr (steradian) 1 sr
//SI unit table (50):
// $ (currency) 1 _
// % (percent) 0.01
// %% (permille) 0.001
// A (ampere) 1 A
// AE (astronomical unit) 149597870659 m
// AU (astronomical unit) 149597870659 m
// Bq (becquerel) 1 s-1
// C (coulomb) 1 s.A
// F (farad) 1 m-2.kg-1.s4.A2
// Gy (gray) 1 m2.s-2
// H (henry) 1 m2.kg.s-2.A-2
// Hz (hertz) 1 s-1
// J (joule) 1 m2.kg.s-2
// Jy (jansky) 1e-26 kg.s-2
// K (kelvin) 1 K
// L (litre) 0.001 m3
// M0 (solar mass) 1.98891944407e+30 kg
// N (newton) 1 m.kg.s-2
// Ohm (ohm) 1 m2.kg.s-3.A-2
// Pa (pascal) 1 m-1.kg.s-2
// S (siemens) 1 m-2.kg-1.s3.A2
// S0 (solar mass) 1.98891944407e+30 kg
// Sv (sievert) 1 m2.s-2
// T (tesla) 1 kg.s-2.A-1
// UA (astronomical unit) 149597870659 m
// V (volt) 1 m2.kg.s-3.A-1
// W (watt) 1 m2.kg.s-3
// Wb (weber) 1 m2.kg.s-2.A-1
// _ (undimensioned) 1 _
// a (year) 31557600 s
// arcmin (arcmin) 0.000290888208666 rad
// arcsec (arcsec) 4.8481368111e-06 rad
// as (arcsec) 4.8481368111e-06 rad
// cd (candela) 1 cd
// cy (century) 3155760000 s
// d (day) 86400 s
// deg (degree) 0.0174532925199 rad
// g (gram) 0.001 kg
// h (hour) 3600 s
// l (litre) 0.001 m3
// lm (lumen) 1 cd.sr
// lx (lux) 1 m-2.cd.sr
// m (metre) 1 m
// min (minute) 60 s
// mol (mole) 1 mol
// pc (parsec) 3.08567758065e+16 m
// rad (radian) 1 rad
// s (second) 1 s
// sr (steradian) 1 sr
// t (tonne) 1000 kg
//Customary unit table (74):
// " (arcsec) 4.8481368111e-06 rad
// "_2 (square arcsec) 2.35044305391e-11 sr
// ' (arcmin) 0.000290888208666 rad
// '' (arcsec) 4.8481368111e-06 rad
// ''_2 (square arcsec) 2.35044305391e-11 sr
// '_2 (square arcmin) 8.46159499408e-08 sr
// : (hour) 3600 s
// :: (minute) 60 s
// ::: (second) 1 s
// Ah (ampere hour) 3600 s.A
// Angstrom (angstrom) 1e-10 m
// Btu (British thermal unit (Int)) 1055.056 m2.kg.s-2
// CM (metric carat) 0.0002 kg
// Cal (large calorie (Int)) 4186.8 m2.kg.s-2
// FU (flux unit) 1e-26 kg.s-2
// G (gauss) 0.0001 kg.s-2.A-1
// Gal (gal) 0.01 m.s-2
// Gb (gilbert) 0.795774715459 A
// Mx (maxwell) 1e-08 m2.kg.s-2.A-1
// Oe (oersted) 79.5774715459 m-1.A
// R (mile) 0.000258 kg-1.s.A
// St (stokes) 0.0001 m2.s-1
// Torr (torr) 133.322368421 m-1.kg.s-2
// USfl_oz (fluid ounce (US)) 2.95735295625e-05 m3
// USgal (gallon (US)) 0.003785411784 m3
// WU (WSRT flux unit) 5e-29 kg.s-2
// abA (abampere) 10 A
// abC (abcoulomb) 10 s.A
// abF (abfarad) 1000000000 m-2.kg-1.s4.A2
// abH (abhenry) 1e-09 m2.kg.s-2.A-2
// abOhm (abohm) 1e-09 m2.kg.s-3.A-2
// abV (abvolt) 1e-08 m2.kg.s-3.A-1
// ac (acre) 4046.8564224 m2
// arcmin_2 (square arcmin) 8.46159499408e-08 sr
// arcsec_2 (square arcsec) 2.35044305391e-11 sr
// ata (technical atmosphere) 98066.5 m-1.kg.s-2
// atm (standard atmosphere) 101325 m-1.kg.s-2
// bar (bar) 100000 m-1.kg.s-2
// beam (undefined beam area) 1 _
// cal (calorie (Int)) 4.1868 m2.kg.s-2
// cwt (hundredweight) 50.80234544 kg
// deg_2 (square degree) 0.000304617419787 sr
// dyn (dyne) 1e-05 m.kg.s-2
// eV (electron volt) 1.60217733e-19 m2.kg.s-2
// erg (erg) 1e-07 m2.kg.s-2
// fl_oz (fluid ounce (Imp)) 2.84130488996e-05 m3
// ft (foot) 0.3048 m
// fu (flux unit) 1e-26 kg.s-2
// fur (furlong) 201.168 m
// gal (gallon (Imp)) 0.00454608782394 m3
// ha (hectare) 10000 m2
// hp (horsepower) 745.7 m2.kg.s-3
// in (inch) 0.0254 m
// kn (knot (Imp)) 0.514773333333 m.s-1
// lb (pound (avoirdupois)) 0.45359237 kg
// ly (light year) 9.46073047e+15 m
// mHg (metre of mercury) 133322.387415 m-1.kg.s-2
// mile (mile) 1609.344 m
// n_mile (nautical mile (Imp)) 1853.184 m
// oz (ounce (avoirdupois)) 0.028349523125 kg
// pixel (pixel) 1 _
// sb (stilb) 10000 m-2.cd
// sq_arcmin (square arcmin) 8.46159499408e-08 sr
// sq_arcsec (square arcsec) 2.35044305391e-11 sr
// sq_deg (square degree) 0.000304617419787 sr
// statA (statampere) 3.33564095198e-10 A
// statC (statcoulomb) 3.33564095198e-10 s.A
// statF (statfarad) 1.11188031733e-12 m-2.kg-1.s4.A2
// statH (stathenry) 899377374000 m2.kg.s-2.A-2
// statOhm (statohm) 899377374000 m2.kg.s-3.A-2
// statV (statvolt) 299.792458 m2.kg.s-3.A-1
// debye (electric dipole moment) 10-18 statC.cm
// u (atomic mass unit) 1.661e-27 kg
// yd (yard) 0.9144 m
// yr (year) 31557600 s
// </srcblock>
//
// </example>
// </module>
//# Dummy class definition for extractor
//# class Quanta {};
} //# NAMESPACE CASACORE - END
#endif
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28