Loading...
Searching...
No Matches
Quanta_module
casa package (libcasa_casa)

More...

## Topics

| Quanta_module_internal_classes
| Internal Quanta_module classes and functions.

## Classes

class | casacore::MeasValue
| More...
struct | casacore::MeasValue_global_functions_Output
| Global functions . More...
class | casacore::MVAngle
| More...
struct | casacore::MVAngle_global_functions_output
| Global functions. More...
class | casacore::MVBaseline
| More...
class | casacore::MVDirection
| More...
class | casacore::MVDoppler
| More...
class | casacore::MVDouble
| More...
class | casacore::MVEpoch
| More...
class | casacore::MVFrequency
| More...
class | casacore::MVPosition
| More...
class | casacore::MVRadialVelocity
| More...
class | casacore::MVTime
| More...
class | casacore::MVuvw
| More...
class | casacore::QBase
| More...
struct | casacore::QBase_global_functions_Output
| Global functions . More...
class | casacore::QC
| More...
struct | casacore::QLogical_global_functions_Quantum_logical_operations
| More...
struct | casacore::QMath_global_functions_Quantum_mathematical_operations
| More...
class | casacore::Quantum< Qtype >
| More...
struct | casacore::Quantum_global_functions_output
| Global functions. More...
class | casacore::QuantumHolder
| More...
struct | casacore::QuantumType_global_functions_QuantumType
| More...
class | casacore::QVector< T >
| More...
class | casacore::Unit
| More...
class | casacore::UnitDim
| More...
class | casacore::UnitMap
| More...
class | casacore::UnitName
| More...
class | casacore::UnitVal
| More...
struct | casacore::UnitVal_global_functions_output
| Global output function . More...
class | casacore::UnitVal_static_initializer
| Static initialisation of UnitVal constants. More...

## Variables

static class casacore::UnitVal_static_initializer | casacore::unitval_static_initializer

## Detailed Description

a module for units and quantities

See below for an overview of the classes in this module.

### Intended use:

Public interface

### Review Status

Reviewed By:
  UNKNOWN
Date Reviewed:
  before2004/08/25
Test programs:
  tUnit tQuantum
Demo programs:
  dMUString

### Etymology

The name Quanta derives from a physical quantity, i.e. a value with units attached.

### Synopsis

The Quanta model deals with units and physical quantities (i.e. values with a unit). Units are handled in the Unit section (see Unit.h). Quantities are handled in the Quantum section (see Quantum.h). In addition the module contains some more general support classes (Euler angles, rotation matrix, pointed string), formatting for time and angle classes and classes containing information for Measures (MeasValue and the derived MV classes like MVEpoch). See the MeasValue section.

### Includes

Including the casa/Quanta.h will take care of all includes necessary for the handling of pure Units and Quantities.

### Physical units

Physical units are basically used in quantities (see Quantum), 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.

### Units

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. m//s == m.s). Separators are acted upon left-to-right (i.e. m/s/A == (m/s)/A; use () to indicate otherwise (e.g. m/(s/A))).

A field is a name, or a unit enclosed in (), optionally followed by an, optionally signed, decimal constant. E.g. m.(m/s)-2 == m-1.s2)

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. <br><strong>Tip:</strong><em> <ul> <li> <tt>'</tt> is used for arcmin <li> <tt>''</tt> or <tt>&quot;</tt> for arcsec <li> : :: and ::: are used for h, min, s respectively; </ul> </em><br> <br><strong>Tip:</strong><em> 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); </em><br> 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 \link casacore::UnitMap UnitMap\endlink). A special set of FITS related units can be added by the <tt>UnitMap::addFITS()</tt> function. For details, see \link casacore::UnitMap UnitMap\endlink. Example: @code km/s/(Mpc.s)2 is identical to km.s-1.Mpc-2.s-2 \endcode 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 <br><strong>Caution:</strong><em> 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"; </em><br> <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 @code 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; } \endcode <br><strong>Tip:</strong><em> 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> </em><br> See the \link casacore::UnitVal UnitVal\endlink for details of calculating with units. See the \link casacore::UnitMap UnitMap\endlink for the details of defining/viewing named units. @anchor Quantum @anchor Quantum <a><h3> Quantums and Quantities </h3> A Quantum is a value with a unit. Quantums are templated on their value type (e.g. <tt>Float</tt>, <tt>Vector&lt;Double&gt;</tt>). <em>Quantity</em> is a typedef for the (probably most common) <tt>Quantum&lt;Double&gt;</tt>. The basic specification of a Quantum is: @code Quantum<Type> (Type value, Unit unit); // or: String unit or: "unit" Quantity(Double value, Unit unit); // or: String unit or: "unit" \endcode E.g. <ul> <li> <tt>Quantity(5.,&quot;m&quot;);</tt> <li> <tt>Quantum&lt;Double&gt; (5.,&quot;m&quot;); // identical to previous</tt> <li> <tt>Vector&lt;Int&gt; a(3); a(3) = 5; Quantum&lt;Vector&lt;Int&gt; &gt;(a,&quot;Jy&quot;);</tt> </ul> The following list of constructors is available. <br><strong>Tip:</strong><em> 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; <tt>Quantum&lt;Type&gt;</tt> can, if Type equals Double, be replaced with <tt>Quantity</tt> </em><br> <ul> <li> <tt>Quantum&lt;Type&gt;() value 0 generated</tt> <li> <tt>Quantum&lt;Type&gt;(Quantum&lt;Type&gt;) copy constructor</tt> <li> <tt>Quantum&lt;Type&gt;(Type factor) value factor generated</tt> <li> <tt>Quantum&lt;Type&gt;(Type factor, Unit unit) specified quantity</tt> <li> <tt>Quantum&lt;Type&gt;(Type factor, Quantum&lt;any&gt; quant) specified factor, the unit from the quant</tt> </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 <tt>Quantum&lt;String&gt;</tt> (whatever that may mean)). <ul> <li> <tt>= assignment of identical &lt;type&gt;</tt> <li> <tt>* *= multiply two Quantums of same &lt;type&gt;</tt> <li> <tt>/ /= divide two Quantums of same &lt;type&gt;</tt> <li> <tt>+ += add two Quantums of same &lt;type&gt; and same unit dimensions</tt> (else exception) <li> <tt>- -= subtract two Quantums of same &lt;type&gt; and same unit dimensions</tt> (else exception) <li> - negate Quantum <li> <tt>== != compare unit dimensions and value of same &lt;type&gt;</tt>. They will be unequal if the unit dimensions do not match or the values (converted to common base units) are unequal <li> <tt>&lt; &gt; compare unit dimensions of same &lt;type&gt;</tt>. Exception if no match, else compare the values <li> <tt>&lt;= &gt;=</tt> 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> <tt>convert(Quantum&lt;any&gt; quant)</tt> will convert the quantum to the units of the specified quant with the same conversion rules as the previous one <li> <tt>get(Quantum&lt;any&gt; quant) will return the converted quantum</tt> </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> <tt>Bool isConform(Unit)</tt> <li> <tt>Bool isConform(Quantum&lt;any&gt;)</tt> <li> <tt>Bool check(UnitVal)</tt> <li> <tt> void assure(UnitVal)</tt> </ul> The value and units of a quantum can be set or retrieved separately by the following member functions: <ul> <li> <tt>Type getValue()</tt> return the value (as Type) of the quantum <li> <tt>Type getValue(Unit)</tt> return the value in specified units <li> <tt>Type getBaseValue()</tt> return the value in canonical units <li> <tt>String getUnit()</tt> return the units of the quantum <li> <tt>void setValue(Type val)</tt> replace the value of the quantum with val, leaving the units the same <li> <tt>void scale(Type)</tt> scale the value (leaving units same) by multiplying with the specified value <li> <tt>void setUnit(Unit)</tt> replace the units of the quantum, leaving the value the same. <li> <tt>void setUnit(Quantum&lt;any&gt;)</tt> ibid </ul> The output operator ('<<') will produce the value of the quantum and its units. Given <tt>Quantity myval(5.,&quot;mJy&quot;);</tt>, <tt>cout &lt;&lt; myval;</tt> will produce: "5.0 mJy"; while <tt>cout &lt;&lt; myval.get(&quot;yW/m2&quot;)</tt> 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> <tt>Quantum&lt;Double&gt; c; // vel of light</tt> <li> <tt>Quantum&lt;Double&gt; G; // Gravitational constant</tt> <li> <tt>Quantum&lt;Double&gt; h; // Planck</tt> <li> <tt>Quantum&lt;Double&gt; HI; // Frequency HI line</tt> <li> <tt>Quantum&lt;Double&gt; R; // Gas constant</tt> <li> <tt>Quantum&lt;Double&gt; NA; // Avogadro</tt> <li> <tt>Quantum&lt;Double&gt; e; // electron charge</tt> <li> <tt>Quantum&lt;Double&gt; mp; // proton mass</tt> <li> <tt>Quantum&lt;Double&gt; mp_me; // mp/me</tt> <li> <tt>Quantum&lt;Double&gt; mu0; // permeability vacuum</tt> <li> <tt>Quantum&lt;Double&gt; epsilon0; // permittivity vacuum</tt> <li> <tt>Quantum&lt;Double&gt; k; // Boltzmann</tt> <li> <tt>Quantum&lt;Double&gt; F; // Faraday</tt> <li> <tt>Quantum&lt;Double&gt; me; // mass electron</tt> <li> <tt>Quantum&lt;Double&gt; re; // radius electron</tt> <li> <tt>Quantum&lt;Double&gt; a0; // Bohr's radius</tt> <li> <tt>Quantum&lt;Double&gt; R0; // Solar radius</tt> <li> <tt>Quantum&lt;Double&gt; k2; // IAU Gaussian grav. const **2</tt> </ul> <p> @anchor MeasValue @anchor MeasValue <a><h3> Values for Measures </h3> 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: @code MV() MV(MV) MV(Double) MV(Vector<Double>) MV(Quantity) MV(Vector<Quantity>) MV(Quantum<Vector<Double> >) \endcode But most have also constructors like: @code MV(Double, Double) MV(Quantity, Quantity) \endcode The actual interpretation is class dependent: see the individual MV classes like \link casacore::MVEpoch MVEpoch\endlink, \link casacore::MVDirection MVDirection\endlink, \link casacore::MVPosition MVPosition\endlink, \link casacore::MVFrequency MVFrequency\endlink, \link casacore::MVDouble MVDouble\endlink, \link casacore::MVRadialVelocity MVRadialVelocity\endlink. \link casacore::MVBaseline MVBaseline\endlink, \link casacore::MVuvw MVuvw\endlink, \link casacore::MVEarthMagnetic MVEarthMagnetic\endlink, A few examples: @code 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. \endcode All MVs have the <tt>+=, -=, ==, !=, &lt;&lt; </tt>operators, and <tt>near()</tt>, <tt>nearAbs()</tt>, <tt>print()</tt> and <tt>adjust()</tt> and <tt>readjust()</tt> (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 \link casacore::MVAngle MVAngle\endlink and \link casacore::MVTime MVTime\endlink, which can do special formatting for time and angles (in earlier documentation they were called HMS etc.). <p> <h3>Motivation</h3> 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. <h3>To Do</h3><ul> <li> inlining <li> look at the problem of rad*rad (which is, in general, not sr) </ul> <h3>Example</h3>@anchor Quanta_example1 <h3> Known units on 960509 </h3> @code // 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

## Variable Documentation

## unitval_static_initializer

class casacore::UnitVal_static_initializer casacore::unitval_static_initializer

static