Quanta.h

Go to the documentation of this file.
00001 //# Quanta.h:  a module for units and quantities
00002 //# Copyright (C) 1998,1999,2000,2004
00003 //# Associated Universities, Inc. Washington DC, USA.
00004 //#
00005 //# This library is free software; you can redistribute it and/or modify it
00006 //# under the terms of the GNU Library General Public License as published by
00007 //# the Free Software Foundation; either version 2 of the License, or (at your
00008 //# option) any later version.
00009 //#
00010 //# This library is distributed in the hope that it will be useful, but WITHOUT
00011 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00012 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
00013 //# License for more details.
00014 //#
00015 //# You should have received a copy of the GNU Library General Public License
00016 //# along with this library; if not, write to the Free Software Foundation,
00017 //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
00018 //#
00019 //# Correspondence concerning AIPS++ should be addressed as follows:
00020 //#        Internet email: aips2-request@nrao.edu.
00021 //#        Postal address: AIPS++ Project Office
00022 //#                        National Radio Astronomy Observatory
00023 //#                        520 Edgemont Road
00024 //#                        Charlottesville, VA 22903-2475 USA
00025 //#
00026 //# $Id$
00027 
00028 #ifndef CASA_QUANTA_H
00029 #define CASA_QUANTA_H
00030 
00031 //# Includes
00032 #include <casacore/casa/aips.h>
00033 
00034 #include <casacore/casa/Quanta/Unit.h>
00035 //# Next one at this place
00036 #include <casacore/casa/Quanta/QC.h>
00037 #include <casacore/casa/Quanta/UnitMap.h>
00038 #include <casacore/casa/Quanta/Quantum.h>
00039 #include <casacore/casa/Quanta/QMath.h>
00040 #include <casacore/casa/Quanta/QLogical.h>
00041 
00042 namespace casacore { //# NAMESPACE CASACORE - BEGIN
00043 
00044 // <module>
00045 // 
00046 
00047 // <summary> a module for units and quantities </summary>
00048 
00049 // <use visibility=export>
00050 
00051 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="tUnit tQuantum"
00052 //       demos="dMUString">
00053 // </reviewed>
00054 
00055 // <prerequisite>
00056 // </prerequisite>
00057 
00058 // <etymology>
00059 // The name Quanta derives from a physical quantity, i.e. a value with
00060 // units attached.
00061 // </etymology>
00062 //
00063 // <synopsis> 
00064 // The Quanta model deals with units and physical quantities
00065 // (i.e. values with a unit).
00066 // Units are handled in the <a href="#Unit">Unit</a> section
00067 // (see <linkto class="Unit">Unit.h</linkto>). 
00068 // Quantities are handled in the <a href="#Quantum">Quantum</a> section
00069 // (see <linkto class="Quantum">Quantum.h</linkto>).
00070 // In addition the module contains some more general support classes
00071 // (<linkto class=Euler>Euler</linkto> angles,
00072 // <linkto class=RotMatrix>rotation matrix</linkto>,
00073 // <linkto class=MUString>pointed string</linkto>), formatting for
00074 // <linkto class=MVTime>time</linkto> and <linkto class=MVAngle>angle</linkto>
00075 // classes and classes containing information for
00076 // Measures (<linkto class=MeasValue>MeasValue</linkto> and the derived MV
00077 // classes like <linkto class=MVEpoch>MVEpoch</linkto>). See the
00078 // <a href="#MeasValue">MeasValue</a> section.
00079 //
00080 // <h3> Includes</h3>
00081 // Including the <src>casa/Quanta.h</src> will take care of all
00082 // includes necessary for the handling of pure Units and Quantities.
00083 //
00084 //  <anchor name="Unit"><h3> Physical units </h3></anchor>
00085 // Physical units are basically used in quantities
00086 // (see <linkto class="Quantum">Quantum</linkto>), i.e.
00087 // a value and a dimension. The Unit class, or one of its subsidiaries,  will
00088 // in general not be called separately. The only reason to make use of these
00089 // classes is to generate additional 'tagged' units, i.e. units with a
00090 // special name, e.g. 'beam' for a telescope  beam, or 'JY', a non-SI name
00091 // for Jy.
00092 //  <h3> Units </h3>
00093 // A Unit is in principle specified as a String (or directly as "string"),
00094 // and can be defined as either a Unit or a String.
00095 // If defined as a Unit, the format of the string will be checked for a
00096 // legal definition and relevant information (e.g. scale, dimension type) is
00097 // cached in the Unit object, leading to (much) faster use; if defined as a
00098 // String, the checking will be postponed
00099 // until any use is made of the information in the string.
00100 //
00101 // A unit is a string of one or more fields separated 
00102 // by 'space' or '.' (to indicate multiply) or '/' (to indicate divide).
00103 // Multiple separators are acted upon (i.e. <src>m//s == m.s</src>).
00104 // Separators are acted upon left-to-right (i.e. <src>m/s/A == (m/s)/A</src>;
00105 // use () to indicate otherwise (e.g. <src>m/(s/A)</src> )).
00106 //
00107 // A field is a name, or a unit enclosed in (), optionally followed by an,
00108 // optionally signed, decimal constant. E.g. <src>m.(m/s)-2 == m-1.s2</src> )
00109 //
00110 // Note that a 'space' or '.' before an opening '(' can be omitted.
00111 //
00112 // A name can consist of case-sensitive letters, '_', ''', ':', '"' and '0'
00113 // ('0' not as first character). Digits 1-9 are allowed if preceded with
00114 // an '_'. Possible legal names are e.g. Jy, R0, R_1, "_2.
00115 // <note role=tip>
00116 // <ul>
00117 //   <li> ' is used for arcmin
00118 //   <li> '' or " for arcsec 
00119 //   <li> : :: and ::: are used for h, min, s respectively.
00120 // </ul>
00121 // </note>
00122 // <note role=tip> The standard naming conventions for SI units are that they
00123 // are all in lowercase, unless derived from a person's name, when they start
00124 // with a capital letter. Notable exceptions are some of the astronomical
00125 // SI related units (e.g. AU).
00126 // </note> 
00127 // A name can be preceded by a (standard) decimal prefix.
00128 //
00129 // A name must be defined in a Unit map before it can be used.
00130 //
00131 // All SI units and some customary units are part of the classes. User
00132 // defined names can be added by the UnitMap::putUser() function (see
00133 // <linkto class="UnitMap">UnitMap</linkto>). A special set of FITS related 
00134 // units can be added by the <src>UnitMap::addFITS()</src> function. For 
00135 // details, see <linkto class="UnitMap">UnitMap</linkto>.
00136 //
00137 // Example:
00138 // <srcblock>
00139 //      km/s/(Mpc.s)2  is identical to km.s-1.Mpc-2.s-2
00140 // </srcblock>
00141 // There are 5 name lists in the UnitMap, which are searched in reverse order:
00142 // <ol>
00143 //   <li> Defining units:       m, kg, s, A, K, cd, mol, rad, sr, _
00144 //   <li> SI units:             including a.o. g, Jy, AU
00145 //   <li> Customary units:      e.g. lb, hp, ly
00146 //   <li> User defined units:   defined by user (e.g. beam, KPH, KM)
00147 //   <li> Cached units: for speed in operations
00148 // </ol>
00149 // All known names can be viewed by running the tUnit test program, or
00150 // using the MapUnit::list() routine.
00151 //
00152 // The definitions that were current on 990915 are given at end of this file
00153 // 
00154 // <note role=caution>
00155 // There is a difference between units without a dimension (non-dimensioned
00156 // I will call them), and undimensioned units. Non-dimensioned examples are
00157 // "", "%"; undimensioned examples: "beam", "pixel".
00158 // </note>
00159 //
00160 //  <h3> Working with units </h3>
00161 // In general units are not used explicitly, but are embedded in quantities
00162 // and coordinates.
00163 //
00164 // Explicit use of units is only necessary if:
00165 // <ol>
00166 //   <li> a unit string has to be tested for legality (e.g. exist JY?)
00167 //   <li> a unit string has to be named (e.g. H0 for km/s/Mpc)
00168 //   <li> some calculation on units has to be performed
00169 //              (e.g. how many hp.s per eV)
00170 // </ol>
00171 //
00172 // For these cases a Unit can be defined as either a String or a Unit. If
00173 // specified as a Unit an automatic check (with exception if illegal) of
00174 // the format of the unit string is performed
00175 // <srcblock>
00176 // Unit a="km/Ms"; String b="Mm/Gs"; //produce 'identical' units a and b
00177 // Unit a("KpH");               // will produce exception
00178 // String a("KpH");             // will be accepted till some other action
00179 //                              // done on a
00180 // // The following will define a unit named 'tag' with a value identical
00181 // // to 5 mJy. After this definition tag can be used as any other unit,
00182 // // e.g. Unit("Gtag/pc") will be a valid unit string.
00183 // UnitMap::putUser("tag",UnitVal(5.,"mJy"),"my own unit name for 5 mJy");
00184 // // The following will calculate how many hp.s per eV
00185 // Double hpeV = (UnitVal("hp.s")/UnitVal("eV")).getFac();
00186 // // maybe after checking for identical dimensions
00187 // if ( UnitVal("hp.s") != UnitVal("eV")) { cout << "unexpected" << endl; }
00188 // </srcblock>
00189 // <note role=tip>
00190 // UnitVal has the following special constants to easily check unit
00191 // dimensions (note that they can be combined to e.g. generate velocity
00192 // as 'UnitVal::LENGTH/UnitVal::TIME')
00193 // <ul>
00194 //  <li> UnitVal::NODIM
00195 //  <li> UnitVal::LENGTH
00196 //  <li> UnitVal::MASS
00197 //  <li> UnitVal::TIME
00198 //  <li> UnitVal::TEMPERATURE
00199 //  <li> UnitVal::ANGLE
00200 //  <li> UnitVal::SOLIDANGLE
00201 //  <li> UnitVal::MOLAR
00202 //  <li> UnitVal::CURRENT
00203 //  <li> UnitVal::INTENSITY
00204 // </ul>
00205 // </note>
00206 //
00207 // See the <linkto class="UnitVal">UnitVal</linkto>
00208 // for details of calculating with units. 
00209 // See the <linkto class="UnitMap">UnitMap</linkto>
00210 // for the details of defining/viewing named units.
00211 // 
00212 //
00213 //  <anchor name="Quantum"><h3> Quantums and Quantities </h3></anchor>
00214 // A Quantum is a  value with a unit. Quantums are templated on their value
00215 // type (e.g. <src>Float</src>, <src>Vector<Double></src>). <em>Quantity</em>
00216 // is a typedef
00217 // for the (probably most common) <src>Quantum<Double></src>.
00218 // The basic specification of a Quantum is:
00219 // <srcblock>
00220 // Quantum<Type> ( Type value, Unit unit);      // or: String unit or: "unit"
00221 // Quantity( Double value, Unit unit);          // or: String unit or: "unit"
00222 // </srcblock>
00223 //
00224 // E.g.
00225 // <ul>
00226 //   <li> <src>Quantity(5.,"m");</src>
00227 //   <li> <src>Quantum<Double> (5.,"m");   // identical to previous</src>
00228 //   <li> <src>Vector<Int> a(3); a(3) = 5; Quantum<Vector<Int> >(a,"Jy");</src>
00229 // </ul>
00230 //
00231 // The following list of constructors is available.
00232 // <note role=tip>
00233 // In the following 'Unit' can be replaced by 'String' (or "string" everywhere.
00234 // The only difference being a check for a legitimate unit string being 
00235 // executed if Unit specified (with exception if error), and a much faster
00236 // execution of the Unit is used repeatedly.
00237 // <src>Quantum<Type></src> can, if Type equals Double, be replaced with 
00238 // <src>Quantity</src>
00239 // </note>
00240 // <ul>
00241 //   <li> <src>Quantum<Type>()                  value 0 generated</src>
00242 //   <li> <src>Quantum<Type>( Quantum<Type>)    copy constructor</src>
00243 //   <li> <src>Quantum<Type>( Type factor)      value factor generated</src>
00244 //   <li> <src>Quantum<Type>( Type factor, Unit unit) specified quantity</src>
00245 //   <li> <src>Quantum<Type>( Type factor, Quantum<any> quant) specified
00246 //                                               factor,
00247 //                                              the unit from the quant</src>
00248 // </ul>
00249 //
00250 // The following operators and functions are defined on Quantums. They are,
00251 // of course, only available if the template Type supports them (e.g. / will
00252 // not be defined for a <src>Quantum<String></src> (whatever that may mean)).
00253 // <ul>
00254 //   <li> <src>=        assignment of identical <type></src>
00255 //   <li> <src>* *=     multiply two Quantums of same <type></src>
00256 //   <li> <src>/ /=     divide two Quantums of same <type></src>
00257 //   <li> <src>+ +=     add two Quantums of same <type> and same unit dimensions</src>
00258 //                      (else exception)
00259 //   <li> <src>- -=     subtract two Quantums of same <type> and same unit dimensions</src>
00260 //                      (else exception)
00261 //   <li>       -       negate Quantum
00262 //   <li> <src>== !=    compare unit dimensions and value of same <type></src>.
00263 //                      They will be unequal if the unit dimensions do not 
00264 //                      match or the values (converted to common 
00265 //                      base units) are unequal
00266 //   <li> <src>< >      compare unit dimensions of same <type></src>.
00267 //                       Exception if no match,
00268 //                      else compare the values
00269 //   <li> <src><= >=</src>      ibid
00270 //   <li> pow(Quantum, Int) raise to an (integer) power
00271 //   <li> abs(Quant)    take absolute value
00272 //   <li> ceil, floor(Quant)
00273 //   <li> sin, cos, tan(Quant) correct units used
00274 //   <li> asin, acos, atan(Quant), atan2(Q,Q) correct units used
00275 //   <li> near, nearAbs
00276 // </ul>
00277 // 
00278 //
00279 // Quanta can be converted to other units by the following set of member
00280 // functions:
00281 // <ul>
00282 //   <li> convert()             will convert the quantum to canonical units.
00283 //                              E.g. given myval=Quantity(5.,"Jy"),
00284 //                              myval.convert() will make myval have the value
00285 //                              Quantity(5.e-26,"kg.s-2")
00286 //   <li> get()                 will return the quantum converted to 
00287 //                              canonical units
00288 //   <li> convert(Unit unit) will convert the quantum to the
00289 //                              specified unit with any remaining dimensions
00290 //                              expressed in canonical units. E.g given
00291 //                              myval as above, myval.convert("W/cm") will
00292 //                              make myval Quantity(5.e-28,"W/cm.m-1.s")
00293 //   <li> get(Unit unit)        will return the quantum converted to unit
00294 //   <li> <src>convert(Quantum<any> quant)</src> will convert the quantum
00295 //                              to the units of the specified quant with the
00296 //                              same conversion rules as the previous one
00297 //   <li> <src>get(Quantum<any> quant) will return the converted quantum</src>
00298 // </ul>
00299 // Quanta can be checked for having the correct unit dimensions (e.g. before
00300 // addition or comparing) by the following two member functions, which will
00301 // return a Bool value or raise an exception:
00302 // <ul>
00303 //   <li> <src>Bool isConform(Unit)</src>
00304 //   <li> <src>Bool isConform(Quantum<any>)</src>
00305 //   <li> <src>Bool check(UnitVal)</src>
00306 //   <li> <src> void assure(UnitVal)</src>
00307 // </ul>
00308 //
00309 // The value and units of a quantum can be set or retrieved separately by the
00310 // following member functions:
00311 // <ul>
00312 //   <li> <src>Type getValue()</src>    return the value (as Type) of the quantum
00313 //   <li> <src>Type getValue(Unit)</src>        return the value in specified units
00314 //   <li> <src>Type getBaseValue()</src>        return the value in canonical units
00315 //   <li> <src>String getUnit()</src>   return the units of the quantum
00316 //   <li> <src>void setValue(Type val)</src> replace the value of the quantum with val,
00317 //                              leaving the units the same
00318 //   <li> <src>void scale(Type)</src>   scale the value (leaving units same) by
00319 //                              multiplying with the specified value
00320 //   <li> <src>void setUnit(Unit)</src> replace the units of the quantum, leaving
00321 //                              the value the same.
00322 //   <li> <src>void setUnit(Quantum<any>)</src> ibid
00323 // </ul>
00324 //
00325 // The output operator ('<<') will produce the value of the quantum and its
00326 // units. Given <src>Quantity myval(5.,"mJy");</src>,
00327 //      <src>cout << myval;</src> will produce:
00328 //      "5.0 mJy"; while <src>cout << myval.get("yW/m2")</src> will produce:
00329 //      ".00005 yW/m2.s"
00330 // 
00331 //
00332 //  <h3> QC class of constant quantities </h3>
00333 // In parallel with the 'C' class of undimensioned constants, the QC class
00334 // contains dimensioned constants.
00335 // On 960509 the following were defined:
00336 // <ul>
00337 //   <li>  <src>Quantum<Double> c;      // vel of light</src>
00338 //   <li>  <src>Quantum<Double> G;      // Gravitational constant</src>
00339 //   <li>  <src>Quantum<Double> h;      // Planck</src>
00340 //   <li>  <src>Quantum<Double> HI;     // Frequency HI line</src>
00341 //   <li>  <src>Quantum<Double> R;      // Gas constant</src>
00342 //   <li>  <src>Quantum<Double> NA;     // Avogadro</src>
00343 //   <li>  <src>Quantum<Double> e;      // electron charge</src>
00344 //   <li>  <src>Quantum<Double> mp;     // proton mass</src>
00345 //   <li>  <src>Quantum<Double> mp_me;  // mp/me</src>
00346 //   <li>  <src>Quantum<Double> mu0;    // permeability vacuum</src>
00347 //   <li>  <src>Quantum<Double> epsilon0; // permittivity vacuum</src>
00348 //   <li>  <src>Quantum<Double> k;      // Boltzmann</src>
00349 //   <li>  <src>Quantum<Double> F;      // Faraday</src>
00350 //   <li>  <src>Quantum<Double> me;     // mass electron</src>
00351 //   <li>  <src>Quantum<Double> re;     // radius electron</src>
00352 //   <li>  <src>Quantum<Double> a0;     // Bohr's radius</src>
00353 //   <li>  <src>Quantum<Double> R0;     // Solar radius</src>
00354 //   <li>  <src>Quantum<Double> k2;     // IAU Gaussian grav. const **2</src>
00355 // </ul>
00356 // 
00357 // <p>
00358 //  <anchor name="MeasValue"><h3> Values for Measures </h3></anchor>
00359 // The MeasValue class derivatives are all named <em>MVmeasure</em>, e.g.
00360 // <em>MVFrequency</em>, and represent the internal representation of the
00361 // specific measure class. There main use is for the Measures module,
00362 // but they can be used alone, e.g. for the conversion to formatted times,
00363 // or the conversion of frequencies from say wavelength to frequency.
00364 // They all have at least the following constructors:
00365 // <srcblock>
00366 //      MV()
00367 //      MV(MV)
00368 //      MV(Double)
00369 //      MV(Vector<Double>)
00370 //      MV(Quantity)
00371 //      MV(Vector<Quantity>)
00372 //      MV(Quantum<Vector<Double> >)
00373 // </srcblock>
00374 // But most have also constructors like:
00375 // <srcblock>
00376 //      MV(Double, Double)
00377 //      MV(Quantity, Quantity)
00378 // </srcblock>
00379 // The actual interpretation is class dependent: see the individual MV classes
00380 // like <linkto class=MVEpoch>MVEpoch</linkto>,
00381 // <linkto class=MVDirection>MVDirection</linkto>,
00382 // <linkto class=MVPosition>MVPosition</linkto>,
00383 // <linkto class=MVFrequency>MVFrequency</linkto>,
00384 // <linkto class=MVDouble>MVDouble</linkto>,
00385 // <linkto class=MVRadialVelocity>MVRadialVelocity</linkto>.
00386 // <linkto class=MVBaseline>MVBaseline</linkto>,
00387 // <linkto class=MVuvw>MVuvw</linkto>,
00388 // <linkto class=MVEarthMagnetic>MVEarthMagnetic</linkto>,
00389 // A few examples:
00390 // <srcblock>
00391 //   MVEpoch(12345, 0.1e-20) will create one epoch (MJD12345.0), but preserving
00392 //                         the precision of all information
00393 //   MVDirection(Quantity(20,"deg"), Quantity(-10,"'")) will create a direction
00394 //                         with an RA of 20 degree, and a DEC of -10 arcmin
00395 //   MVFrequency(Quantity(5,"keV")) will create a frequency corresponding to
00396 //                         the specified energy.
00397 // </srcblock>
00398 // All MVs have the <src>+=, -=, ==, !=, << </src>operators, and <src>near()</src>,
00399 // <src>nearAbs()</src>, <src>print()</src> and <src>adjust()</src>
00400 // and <src>readjust()</src> (which in general
00401 // normalise to a value of 1 (e.g. MVDirection), or recalculates high
00402 // precision values (e.g. MVEpoch) functions.<br>
00403 // Information can be viewed with many <em>get</em> functions. In most cases
00404 // getValue() will return the internal value as either Double or 
00405 // Vector<Double>; get() will return the same, or converted values (e.g.
00406 // a vector of length, angle, angle for MVPosition; while special
00407 // one like getAngle() or getAngle(unit), getTime() etc will return Quantums
00408 // (with optional conversion to specified units).<br>
00409 // In general the Measure classes can be used without worrying about the
00410 // MeasValues, since most Measure constructors have enough flexibility (and
00411 // their own get()'s) to be able to use them independently).<br>
00412 // Special cases are <linkto class=MVAngle>MVAngle</linkto> and 
00413 // <linkto class=MVTime>MVTime</linkto>, which can do special formatting for
00414 // time and angles (in earlier documentation they were called HMS etc.).
00415 // <p>
00416 
00417 // </synopsis> 
00418 //
00419 // <motivation>
00420 // The Quanta model originated to handle physical quantities independent of their
00421 // units.
00422 // Units were introduced in the described way to be able to handle any
00423 // possible physical unit.
00424 // </motivation>
00425 //
00426 // <todo asof="1998/07/22">
00427 //   <li> inlining
00428 //   <li> look at the problem of rad*rad (which is, in general, not sr)
00429 // </todo>
00430 //
00431 // <example>
00432 //  <h3> Known units on 960509 </h3>
00433 // <srcblock>
00434 // // UnitMap::list() will produce the following list:
00435 //List all defined symbols
00436 //
00437 //Prefix table (20):
00438 //    E         (exa)                        1e+18
00439 //    G         (giga)                       1000000000
00440 //    M         (mega)                       1000000
00441 //    P         (peta)                       1e+15
00442 //    T         (tera)                       1e+12
00443 //    Y         (yotta)                      1e+24
00444 //    Z         (zetta)                      1e+21
00445 //    a         (atto)                       1e-18
00446 //    c         (centi)                      0.01
00447 //    d         (deci)                       0.1
00448 //    da        (deka)                       10
00449 //    f         (femto)                      1e-15
00450 //    h         (hecto)                      100
00451 //    k         (kilo)                       1000
00452 //    m         (milli)                      0.001
00453 //    n         (nano)                       1e-09
00454 //    p         (pico)                       1e-12
00455 //    u         (micro)                      1e-06
00456 //    y         (yocto)                      1e-24
00457 //    z         (zepto)                      1e-21
00458 //Defining unit table (10):
00459 //    A         (ampere)                     1 A
00460 //    K         (kelvin)                     1 K
00461 //    _         (undimensioned)              1 _
00462 //    cd        (candela)                    1 cd
00463 //    kg        (kilogram)                   1 kg
00464 //    m         (metre)                      1 m
00465 //    mol       (mole)                       1 mol
00466 //    rad       (radian)                     1 rad
00467 //    s         (second)                     1 s
00468 //    sr        (steradian)                  1 sr
00469 //SI unit table (50):
00470 //    $         (currency)                   1 _
00471 //    %         (percent)                    0.01
00472 //    %%        (permille)                   0.001
00473 //    A         (ampere)                     1 A
00474 //    AE        (astronomical unit)          149597870659 m
00475 //    AU        (astronomical unit)          149597870659 m
00476 //    Bq        (becquerel)                  1 s-1
00477 //    C         (coulomb)                    1 s.A
00478 //    F         (farad)                      1 m-2.kg-1.s4.A2
00479 //    Gy        (gray)                       1 m2.s-2
00480 //    H         (henry)                      1 m2.kg.s-2.A-2
00481 //    Hz        (hertz)                      1 s-1
00482 //    J         (joule)                      1 m2.kg.s-2
00483 //    Jy        (jansky)                     1e-26 kg.s-2
00484 //    K         (kelvin)                     1 K
00485 //    L         (litre)                      0.001 m3
00486 //    M0        (solar mass)                 1.98891944407e+30 kg
00487 //    N         (newton)                     1 m.kg.s-2
00488 //    Ohm       (ohm)                        1 m2.kg.s-3.A-2
00489 //    Pa        (pascal)                     1 m-1.kg.s-2
00490 //    S         (siemens)                    1 m-2.kg-1.s3.A2
00491 //    S0        (solar mass)                 1.98891944407e+30 kg
00492 //    Sv        (sievert)                    1 m2.s-2
00493 //    T         (tesla)                      1 kg.s-2.A-1
00494 //    UA        (astronomical unit)          149597870659 m
00495 //    V         (volt)                       1 m2.kg.s-3.A-1
00496 //    W         (watt)                       1 m2.kg.s-3
00497 //    Wb        (weber)                      1 m2.kg.s-2.A-1
00498 //    _         (undimensioned)              1 _
00499 //    a         (year)                       31557600 s
00500 //    arcmin    (arcmin)                     0.000290888208666 rad
00501 //    arcsec    (arcsec)                     4.8481368111e-06 rad
00502 //    as        (arcsec)                     4.8481368111e-06 rad
00503 //    cd        (candela)                    1 cd
00504 //    cy        (century)                    3155760000 s
00505 //    d         (day)                        86400 s
00506 //    deg       (degree)                     0.0174532925199 rad
00507 //    g         (gram)                       0.001 kg
00508 //    h         (hour)                       3600 s
00509 //    l         (litre)                      0.001 m3
00510 //    lm        (lumen)                      1 cd.sr
00511 //    lx        (lux)                        1 m-2.cd.sr
00512 //    m         (metre)                      1 m
00513 //    min       (minute)                     60 s
00514 //    mol       (mole)                       1 mol
00515 //    pc        (parsec)                     3.08567758065e+16 m
00516 //    rad       (radian)                     1 rad
00517 //    s         (second)                     1 s
00518 //    sr        (steradian)                  1 sr
00519 //    t         (tonne)                      1000 kg
00520 //Customary unit table (74):
00521 //    "         (arcsec)                     4.8481368111e-06 rad
00522 //    "_2       (square arcsec)              2.35044305391e-11 sr
00523 //    '         (arcmin)                     0.000290888208666 rad
00524 //    ''        (arcsec)                     4.8481368111e-06 rad
00525 //    ''_2      (square arcsec)              2.35044305391e-11 sr
00526 //    '_2       (square arcmin)              8.46159499408e-08 sr
00527 //    :         (hour)                       3600 s
00528 //    ::        (minute)                     60 s
00529 //    :::       (second)                     1 s
00530 //    Ah        (ampere hour)                3600 s.A
00531 //    Angstrom  (angstrom)                   1e-10 m
00532 //    Btu       (British thermal unit (Int)) 1055.056 m2.kg.s-2
00533 //    CM        (metric carat)               0.0002 kg
00534 //    Cal       (large calorie (Int))        4186.8 m2.kg.s-2
00535 //    FU        (flux unit)                  1e-26 kg.s-2
00536 //    G         (gauss)                      0.0001 kg.s-2.A-1
00537 //    Gal       (gal)                        0.01 m.s-2
00538 //    Gb        (gilbert)                    0.795774715459 A
00539 //    Mx        (maxwell)                    1e-08 m2.kg.s-2.A-1
00540 //    Oe        (oersted)                    79.5774715459 m-1.A
00541 //    R         (mile)                       0.000258 kg-1.s.A
00542 //    St        (stokes)                     0.0001 m2.s-1
00543 //    Torr      (torr)                       133.322368421 m-1.kg.s-2
00544 //    USfl_oz   (fluid ounce (US))           2.95735295625e-05 m3
00545 //    USgal     (gallon (US))                0.003785411784 m3
00546 //    WU        (WSRT flux unit)             5e-29 kg.s-2
00547 //    abA       (abampere)                   10 A
00548 //    abC       (abcoulomb)                  10 s.A
00549 //    abF       (abfarad)                    1000000000 m-2.kg-1.s4.A2
00550 //    abH       (abhenry)                    1e-09 m2.kg.s-2.A-2
00551 //    abOhm     (abohm)                      1e-09 m2.kg.s-3.A-2
00552 //    abV       (abvolt)                     1e-08 m2.kg.s-3.A-1
00553 //    ac        (acre)                       4046.8564224 m2
00554 //    arcmin_2  (square arcmin)              8.46159499408e-08 sr
00555 //    arcsec_2  (square arcsec)              2.35044305391e-11 sr
00556 //    ata       (technical atmosphere)       98066.5 m-1.kg.s-2
00557 //    atm       (standard atmosphere)        101325 m-1.kg.s-2
00558 //    bar       (bar)                        100000 m-1.kg.s-2
00559 //    beam      (undefined beam area)        1 _
00560 //    cal       (calorie (Int))              4.1868 m2.kg.s-2
00561 //    cwt       (hundredweight)              50.80234544 kg
00562 //    deg_2     (square degree)              0.000304617419787 sr
00563 //    dyn       (dyne)                       1e-05 m.kg.s-2
00564 //    eV        (electron volt)              1.60217733e-19 m2.kg.s-2
00565 //    erg       (erg)                        1e-07 m2.kg.s-2
00566 //    fl_oz     (fluid ounce (Imp))          2.84130488996e-05 m3
00567 //    ft        (foot)                       0.3048 m
00568 //    fu        (flux unit)                  1e-26 kg.s-2
00569 //    fur       (furlong)                    201.168 m
00570 //    gal       (gallon (Imp))               0.00454608782394 m3
00571 //    ha        (hectare)                    10000 m2
00572 //    hp        (horsepower)                 745.7 m2.kg.s-3
00573 //    in        (inch)                       0.0254 m
00574 //    kn        (knot (Imp))                 0.514773333333 m.s-1
00575 //    lb        (pound (avoirdupois))        0.45359237 kg
00576 //    ly        (light year)                 9.46073047e+15 m
00577 //    mHg       (metre of mercury)           133322.387415 m-1.kg.s-2
00578 //    mile      (mile)                       1609.344 m
00579 //    n_mile    (nautical mile (Imp))        1853.184 m
00580 //    oz        (ounce (avoirdupois))        0.028349523125 kg
00581 //    pixel     (pixel)                      1 _
00582 //    sb        (stilb)                      10000 m-2.cd
00583 //    sq_arcmin (square arcmin)              8.46159499408e-08 sr
00584 //    sq_arcsec (square arcsec)              2.35044305391e-11 sr
00585 //    sq_deg    (square degree)              0.000304617419787 sr
00586 //    statA     (statampere)                 3.33564095198e-10 A
00587 //    statC     (statcoulomb)                3.33564095198e-10 s.A
00588 //    statF     (statfarad)                  1.11188031733e-12 m-2.kg-1.s4.A2
00589 //    statH     (stathenry)                  899377374000 m2.kg.s-2.A-2
00590 //    statOhm   (statohm)                    899377374000 m2.kg.s-3.A-2
00591 //    statV     (statvolt)                   299.792458 m2.kg.s-3.A-1
00592 //    debye     (electric dipole moment)     10-18 statC.cm
00593 //    u         (atomic mass unit)           1.661e-27 kg
00594 //    yd        (yard)                       0.9144 m
00595 //    yr        (year)                       31557600 s
00596 // </srcblock>
00597 //
00598 // </example>
00599 // </module>
00600 
00601 //# Dummy class definition for extractor
00602 //# class Quanta {};
00603 
00604 
00605 } //# NAMESPACE CASACORE - END
00606 
00607 #endif
00608 
00609 
00610 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 31 Aug 2016 for casa by  doxygen 1.6.1