/usr/include/casacore/measures/Measures/MeasFrame.h is in casacore-dev 2.2.0-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 | //# MeasFrame.h: Container for Measure frame
//# Copyright (C) 1996-2003,2007
//# 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: aips2-request@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
//#
//# $Id$
#ifndef MEASURES_MEASFRAME_H
#define MEASURES_MEASFRAME_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/casa/Arrays/Vector.h>
#include <casacore/measures/Measures/Measure.h>
#include <casacore/casa/iosfwd.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
//# Forward Declarations
class MVEpoch;
class MVPosition;
class MVDirection;
class MVRadialVelocity;
class MeasComet;
class FrameRep;
class MCFrame;
template <class T> class Vector;
template <class Qtype> class Quantum;
// <summary> Container for Measure frame </summary>
// <use visibility=export>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="tMeasure" demos="">
// </reviewed>
// <prerequisite>
// <li> <linkto class=Measure>Measure</linkto> class
// <li> <linkto class=MeasRef>MeasRef</linkto> class
// </prerequisite>
//
// <etymology>
// From Measure and Frame
// </etymology>
//
// <synopsis>
// Measurements are made in a reference frame (epoch, position, direction,
// ...).<br>
// The class is a container for the reference frame Measures (MEpoch etc).
// Since a frame will possibly be used by many different Measures, it behaves
// as a smart pointer, with reference rather than copy characteristics.
// Since it caches all its operations, it is advisable to have a 'global'
// MeasFrame across an execution, resetting (or setting) its values
// when appropriate. The frame can also contain other related information. At
// the moment the orbit of a solar system body (MeasComet) can be set.
// In future the planetary ephemeris used (e.g. DE205) and environmental
// information like refraction data will be added.
//
// A MeasFrame is constructed by setting the appropriate Measures, either in
// a constructor, or with a set(). The input to the constructors and set are
// Measures.<br>
//
// Inside the frames automatic conversion to the most appropriate usage of
// its values is done (e.g. time to TBD time, position to astronomical
// longitude). These conversions are done only if an explicit
// Measure::Convert was used that needed information, e.g. the following
// code:
// <srcblock>
// MeasFrame frame(obser); // obser is an MPosition
// MEpoch::Convert conv(MEpoch(12345), MEpoch::Ref(MEpoch::LAST,obser));
// MEpoch last = conv();
// </srcblock>
// will set-up a state machine to convert UTC(default) to LAST in conv; the
// next call will do the actual conversion. During this conversion, the
// astronomical longitude (among others) will be needed to convert to
// local sidereal time. conv will ask (getLong()) this from the frame, which
// will calculate it (including possible other conversions) from the
// observatory's position specified in a frame. Any calculation done will be
// cached (e.g. a Nutation calculation in this case for dpsi), and used in
// subsequent conversions using the same frame.<br>
// Furthermore, a frame will often be regularly updated (e.g. coordinate
// conversion for a series of times). To make use of cached information, and
// to speed up as much as possible, <src>reset...()</src> functions are
// available. These reset functions accept the same range of input parameter
// types as the <linkto class=MeasConvert>MeasConvert</linkto> () operator,
// and will keep any determined conversion machines and related information
// intact, only recalculating whatever is necessary.<br>
// The actual frame calculations and interrogations are done in a separate
// <linkto class=MCFrame>MCFrame</linkto> hidden class, which attaches itself
// to MeasFrame when and if necessary (see there if you are really curious).<br>.
// get...() functions can return frame measures. Only when the frame has been
// attached to a calculating machine *MCFrame) are these values available.
// This attachment is done if the frame has been actively used by a
// Measure::Convert engine, or if explicitly done by the
// <src>MCFrame::make(MeasFrame &)</src> static method.
// <note role=caution> An explicit (or implicit) call to MCFrame::make will
// load the whole conversion machinery (including Tables) into your
// linked module).</note><br>
// <linkto class=Aipsrc>Aipsrc keywords</linkto> can be used for additional
// (highly specialised) additional internal conversion parameters.
// </synopsis>
//
// <example>
// <srcblock>
// MEpoch my_epoch(Quantity(MeasData::MJDB1950,"d")); // an epoch
// MeasFrame frame(my_epoch); // used in a frame
// </srcblock>
// </example>
//
// <motivation>
// To separate the frame definition from the measure type
// </motivation>
//
// <todo asof="1997/04/16">
// </todo>
class MeasFrame {
public:
//# Friends
// Output a frame
friend ostream &operator<<(ostream &os, MeasFrame &mf);
// Machinery
// <group>
friend class MCFrame;
friend Bool MCFrameGetdbl(void *dmf, uInt tp, Double &result);
friend Bool MCFrameGetmvdir(void *dmf, uInt tp, MVDirection &result);
friend Bool MCFrameGetmvpos(void *dmf, uInt tp, MVPosition &result);
friend Bool MCFrameGetuint(void *dmf, uInt tp, uInt &result);
// </group>
//# Enumerations
// Enumeration for the different farme entries possible. This can be used
// to find out if a certain conversion needs the frame. It will be
// used in a registration/notify environment to enable bypassing of
// some new conversion settings.
enum FrameTypes {
EPOCH = 1,
POSITION = 2,
DIRECTION = 4,
VELOCITY = 8,
COMET = 16 };
//# Constructors
// Default constructor
MeasFrame();
// Construct frame with specified measures
// <thrown>
// <li> AipsError if a non-frame Measure
// </thrown>
// <group>
MeasFrame(const Measure &meas1);
MeasFrame(const Measure &meas1, const Measure &meas2);
MeasFrame(const Measure &meas1, const Measure &meas2,
const Measure &meas3);
// </group>
// Copy constructor (reference semantics)
MeasFrame(const MeasFrame &other);
// Copy assignment (reference semantics)
MeasFrame &operator=(const MeasFrame &other);
// Destructor
~MeasFrame();
//# Operators
// Comparisons
// <group>
Bool operator==(const MeasFrame &other) const;
Bool operator!=(const MeasFrame &other) const;
// </group>
//# General member functions
// Test if empty (i.e. no measure filled in)
Bool empty() const;
// Set frame elements
// <thrown>
// <li> AipsError if a non-frame Measure
// <li> AipsError if illegal or non-existant MeasComet given
// </thrown>
// <group>
void set(const Measure &meas1);
void set(const Measure &meas1, const Measure &meas2);
void set(const Measure &meas1, const Measure &meas2,
const Measure &meas3);
void set(const MeasComet &meas);
// </group>
// Reset a frame element and its cached derived values.
// <thrown>
// <li> AipsError if the specific Measure not yet present in frame
// </thrown>
// <group>
void resetEpoch(Double val);
void resetEpoch(const Vector<Double> &val);
void resetEpoch(const Quantum<Double> &val);
void resetEpoch(const Quantum<Vector<Double> > &val);
void resetEpoch(const MVEpoch &val);
void resetEpoch(const Measure &val);
void resetPosition(const Vector<Double> &val);
void resetPosition(const Quantum<Vector<Double> > &val);
void resetPosition(const MVPosition &val);
void resetPosition(const Measure &val);
void resetDirection(const Vector<Double> &val);
void resetDirection(const Quantum<Vector<Double> > &val);
void resetDirection(const MVDirection &val);
void resetDirection(const Measure &val);
void resetRadialVelocity(const Vector<Double> &val);
void resetRadialVelocity(const Quantum<Vector<Double> > &val);
void resetRadialVelocity(const MVRadialVelocity &val);
void resetRadialVelocity(const Measure &val);
void resetComet(const MeasComet &val);
// </group>
// Get the epoch pointer (0 if not present)
const Measure* epoch() const;
// Get the position pointer (0 if not present)
const Measure* position() const;
// Get the direction pointer (0 if not present)
const Measure* direction() const;
// Get the radial velocity pointer (0 if not present)
const Measure* radialVelocity() const;
// Get the comet pointer (0 if not present)
const MeasComet* comet() const;
// Get data from frame. Only available if appropriate measures are set,
// and the frame is in a calculating state.
// <group>
// Get TDB in days
Bool getTDB(Double &tdb) const;
// Get UT1 in days
Bool getUT1(Double &tdb) const;
// Get TT in days
Bool getTT(Double &tdb) const;
// Get the ITRF longitude (in rad)
Bool getLong(Double &tdb) const;
// Get the ITRF latitude (in rad)
Bool getLat(Double &tdb) const;
// Get the position
Bool getITRF(MVPosition &tdb) const;
// Get the geocentric position (in m)
Bool getRadius(Double &tdb) const;
// Get the geodetic latitude
Bool getLatGeo(Double &tdb) const;
// Get the LAST (in days)
Bool getLAST(Double &tdb) const;
// Get the LAST (in rad)
Bool getLASTr(Double &tdb) const;
// Get J2000 coordinates (direction cosines) and its longitude/latitude (rad)
// <group>
Bool getJ2000(MVDirection &tdb) const;
Bool getJ2000Long(Double &tdb) const;
Bool getJ2000Lat(Double &tdb) const;
// </group>
// Get B1950 coordinates (direction cosines)
// <group>
Bool getB1950(MVDirection &tdb) const;
Bool getB1950Long(Double &tdb) const;
Bool getB1950Lat(Double &tdb) const;
// </group>
// Get apparent coordinates (direction cosines)
// <group>
Bool getApp(MVDirection &tdb) const;
Bool getAppLong(Double &tdb) const;
Bool getAppLat(Double &tdb) const;
// </group>
// Get LSR radial velocity (m/s)
Bool getLSR(Double &tdb) const;
// Get the comet table reference type
Bool getCometType(uInt &tdb) const;
// Get the comet coordinates
Bool getComet(MVPosition &tdb) const;
// </group>
private:
//# Data
// Representation of MeasFrame
FrameRep *rep;
//# Member functions
// Create an instance of the MeasFrame class
void create();
// Fill a MeasFrame element
// <group>
void fill(const Measure *in);
void fill(const MeasComet *in);
// </group>
// Make full Epoch
void makeEpoch();
// Make full Position
void makePosition();
// Make full Direction
void makeDirection();
// Make full RadialVelocity
void makeRadialVelocity();
// Make full Comet
void makeComet();
// Throw reset error
void errorReset(const String &txt);
// Lock the frame to make sure deletion occurs when needed
void lock(uInt &locker);
// Unlock the frame
void unlock(const uInt locker);
};
//# Global functions
// <summary> Global functions </summary>
// <group name=Output>
// Output a frame
ostream &operator<<(ostream &os, MeasFrame &mf);
// </group>
} //# NAMESPACE CASACORE - END
#endif
|