[Previous]
[Next]
NAME:
rank_array
PURPOSE:
Calculates rank array for a given index array
CATEGORY:
gen/idl/toolbox/math
CALLING SEQUENCE:
rank = rank_array(index)
INPUTS:
index array; type: integer
index array, i.e. array of indices returned
by the IDL sort function
OUTPUTS:
rank array; type: integer
rank array
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
IsType
CALLED BY:
boost
PROCEDURE:
The rank array inverts the index array. Applying rank to the sorted
array returns the array back into its original order: A[rank[index]] = A
MODIFICATION HISTORY:
JAN-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
READ_SMEI_OP
PURPOSE:
Read a SMEI ops specification from a file.
CATEGORY:
OPS
CALLING SEQUENCE:
op = read_smei_op(file)
INPUTS:
file string The file from which to read the ops specifier.
OUTPUTS:
op string The specifier.
CALLS: ***
smei_msg
CALLED BY:
PARSE_OP
PROCEDURE:
If the filename is a full path, then it is used unchanged. If
it is a plain name, then the current directory is checked
first followed by the directory specified by the SMEI_OPS_PATH
environment variable. If no extension is given, then ".sop" is
used.
MODIFICATION HISTORY:
Original: 4/11/03; SJT
[Previous]
[Next]
NAME:
ReadSynopticMap
PURPOSE:
Read a synoptic map file in standard form
CATEGORY:
I/O
CALLING SEQUENCE:
map = ReadSynopticMap( Rotation )
INPUTS:
Rotation integer scalar Carrington rotation number
OPTIONAL INPUT PARAMETERS:
/spgreen if set, Sac Peak Fe XIV map is read
/spred if set, Sac Peak Fe X map is read
OUTPUTS:
map 2D float array
OPTIONAL OUTPUT PARAMETERS:
CALLS: ***
FILEPATH, InitVar, flt_read
CALLED BY:
RemoteView_Init_Display
RESTRICTIONS:
keywords are processed in the order given above. The first
keyword present is processed; all others are ignored.
PROCEDURE:
The Sac Peak should be located in the $dat/map/sacpeak directory.
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS, pphick@ucsd.edu)
[Previous]
[Next]
NAME:
refine_pointing
PURPOSE:
CATEGORY:
CALLING SEQUENCE:
abg = refine_pointing(good_pos, bad_pos, /degrees)
INPUTS:
good_pos
bad_pos
OPTIONAL INPUT PARAMETERS:
OUTPUTS:
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
MEAN, ToRadians
PROCEDURE:
MODIFICATION HISTORY:
MAR-2003, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView
PURPOSE:
Calculates image of sky from 3D density matrix for a given viewer location
and viewing direction.
CATEGORY:
Volume rendering
CALLING SEQUENCE:
PRO RemoteView, $
getcube = getcube, $
fovcube = FOVCube, $ ; Output only when /getcube is set
cube = Cube, $
drawecliptic= DrawEcliptic, $
meshecliptic= MeshEcliptic, $
meshhcs = MeshHCS, $
;mergehcs = MergeHCS, $
voxel = Voxel, $
base_name = base_name, $
noplot = NoPlot, $
_extra = _extra, $
images = images, $
M3D = M3D, $
V3D = V3D, $
D3D = D3D, $
silent = silent
OPTIONAL INPUT PARAMETERS:
Most keywords are those described in RemoteView_Init.
/cube add bounding cube
/drawecliptic add ecliptic boundary
/meshecliptic add mesh in ecliptic
/noplot suppresses all plotting activity
/meshhcs add heliospheric current sheet as mesh surface
voxel array, type: integer; default: 1
up to a 4 element array of values 0,1,2 or 3.
Values 0,1 and 2 result in a 3D remote view (see RemoteView_Display3D:
0: skip rgbo calculation (bodies and orbits only)
1: use IDL Voxel_Proj function
2: home-brew rgbo rendering (needs work)
Value 3 results in a 2D image (see RemoteView_Display2D.
The keyword f3dfnc determines the content of the 2D image (the default
is the Thomson scattering brightness)
base_dir scalar; type: string; default: getenv('TEMP')
destination directory for output image files
base_name array; type: string
base name used for output image files. A 3-digit counter for each of the
views rendered is appended to the base name.
Especially if keyword 'voxel' is specified as an array (i.e. multiple
images are calculated for each view) then a separate base_name should be
specified for each of the 'voxel' entries.
/getcube ?
OUTPUTS:
(to screen or image file)
images=images
scalar or array; type: string
fully-qualified names of all output images created
fovcube=FOVCube
Output only when /getcube is set
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CV_COORD, CvSky, InitVar, IsType, REVERSE, RemoteView_BodyLoc, RemoteView_BodySize
RemoteView_CubeFrame, RemoteView_CurrentSheet, RemoteView_Destroy
RemoteView_Destroy_FOV, RemoteView_Display2D, RemoteView_Display3D
RemoteView_FOV, RemoteView_FOV_loc, RemoteView_Init, RemoteView_VertexMap
RemoteView_ZEclipticPlane, SuperArray, T3D, big_orbit, boost, destroyvar, gridgen
jpl_body
CALLED BY:
vu_RemoteView
PROCEDURE:
MODIFICATION HISTORY:
APR-2001, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
JUN-2004, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Added option to plot orbits for planets and Moon (depends on JPL ephemeris)
A negative Voxel value now suppresses labeling in RemoteView_Display3D.
[Previous]
[Next]
NAME:
RemoteView_BodyLoc
PURPOSE:
Get position coordinates of Earth in a Cartesian
heliographic coordinate system (see SkyGrid for
definition coordinate system).
CATEGORY:
CALLING SEQUENCE:
FUNCTION RemoteView_BodyLoc, TT, body=body, silent=silent
INPUTS:
TT array[1]; type: time structure
time
OPTIONAL INPUT PARAMETERS:
body=body scalar; type: string
name of body
/silent if set, suppresses informational messages
OUTPUTS:
Earth array[3] X,Y,Z coordinates of Earth (in data units)
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CV_COORD, CvSky, InitVar, KeplerOrbit, NewcombSun, TimeGet, TimeOp, TimeSet, big_eph
jpl_body, sgp_body
CALLED BY:
RemoteView
RESTRICTIONS:
PROCEDURE:
NewcombSun is used to get the geocentric ecliptic coordinates
of the Sun. The heliocentric ecliptic coordinates of Earth
are given by the opposite point (add 180 deg to longitude;
change sign on the latitude. Then Ecliptic_Heliog is used to
convert to heliographic coordinates.
MODIFICATION HISTORY:
FEB-1997, Paul Hick (UCSD/CASS)
OCT-2006, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Replaced call to jpl_eph by call to big_eph. This makes it easier
to add bodies processed by the USNO asteroid ephemeris and any
ephemerides downloaded from the Minor Planet Center.
[Previous]
[Next]
NAME:
RemoteView_BodySize
PURPOSE:
Determine angular size of body
CATEGORY:
sat/idl/remoteview
CALLING SEQUENCE:
FUNCTION RemoteView_BodySize, rView, rSphere, fake, rOuter, fov, degrees=degrees
INPUTS:
rView scalar; type: float
distance of viewing location to body (AU)
rSphere scalar; type: float
actual radius of body (AU)
fake scalar; type: float
fake angular size to be used for displaying body
as a fraction of the FOV size
rOuter scalar; type: float
outer radius of data sphere
fov array[2]; type: double
size of FOV in hor and vert direction
OPTIONAL INPUT PARAMETERS:
/degrees if set, all angles are in degrees (default: radians)
OUTPUTS:
Result angular size of body (but never less than fake size)
expressed as fraction of the FOV size
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
ToRadians
CALLED BY:
RemoteView
PROCEDURE:
MODIFICATION HISTORY:
JULY-2001, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_CMEDensity
PURPOSE:
Adds CME density to remoteview
CATEGORY:
CALLING SEQUENCE:
RemoteView_CMEDensity, TT0, TT, nDim, rEdge, CMEmin, CMEmax, rot_cme=rot_cme
INPUTS:
TT0 array[1]; type: time structure
time assigned to the CME density matrix read from file
Usually the same as the 3D solar wind density matrix with
which the CME density is merged.
TT array[1]; type: time structure
time at which CME is displayed; the CME matrix expands
at a constant speed of V=400 km/s from time TT0 to TT
(usually TT will be a couple of days later than TT0)
The heliospheric matrix is defined by:
nDim array[3]; type: integer
# longitudinal, latitudinal and radial grid points
rEdge array[2]; type: float
inner and outer radius of radial grid (AU)
OPTIONAL INPUTS:
rot_cme=rot_cme scalar or array[2]
extra rotations applied to the CME
OUTPUTS:
CMEmin scalar; type: float
CMEmax scalar; type: float
min and max normalized density in CME matrix
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
ArrayLocation, CV_COORD, EulerRotate, FILEPATH, MEAN, TimeOp, TimeString, TimeUnit
ToRadians, flt_read, gridgen
CALLED BY:
RemoteView_Init_Matrix
PROCEDURE:
MODIFICATION HISTORY:
SEP-1999, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_Colors
PURPOSE:
Defines colors to be used for coloring heliospheric bodies
CATEGORY:
RemoteView package: volume rendering
CALLING SEQUENCE:
PRO RemoteView_Colors, colortable, $
White, Black, Purple, Red, Green, $
Greyish, Yellowish, Blueish, Reddish, Greenish
INPUTS:
(none)
OUTPUTS:
colortable
array[N,3]; type: byte; currently N=236
RGB color table used for coloring heliospheric objects
(planets, etc.).
The color table is patched together from a number of IDL
color tables. The file skycolor.pro describes the color table
Black : 0 1
White : 2 3
Purple : 4 5
Red : 6 7
Green : 8 9
Blue : 10 11
Earth : 12 15
Greyish : 16 59
Blueish : 60 103
Yellowish: 104 147
Reddish : 148 191
Greenish : 192 235
Each of these entries is returned as a two-element argument.
White, Black, Purple, Red, Green
. Greyish, Yellowish, Blueish, Reddish, Greenish
array[2]; type: integer
indices into the color arrays 'reds','green','blues' for
beginning and start color
INCLUDE:
@compile_opt.pro ; On error, return to caller
@skycolors.pro ; Dummy comment for Linux
CALLS: ***
FILEPATH, flt_read, who_am_i
INCLUDE:
@skycolors.pro
CALLED BY:
RemoteView_Init_Display
SIDE EFFECTS:
Needs files remoteview_colors_info.txt and remoteview_colors.txt,
storing the color table information.
RESTRICTIONS:
PROCEDURE:
Currently the number of elements is restricte to 236 colors to make things work
on Windows NT.
MODIFICATION HISTORY:
JUN-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Split off from old skycolors.pro (now obsolete)
AUG-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
The two ascii files with color table info is now
looked for in the same directory as the source code.
[Previous]
[Next]
NAME:
RemoteView_CubeFrame
PURPOSE:
Draws outline of 3D data cube
CATEGORY:
Graphics
CALLING SEQUENCE:
Cube = RemoteView_CubeFrame(nS, color=Color)
INPUTS:
nS integer; type: float
cube size in data units
(if nL is fo type float it is rounded up to the
next integer)
OPTIONAL INPUT PARAMETERS:
color=Color scalar color index used for drawing
(if omitted then !p.color is used)
OUTPUTS:
Cube
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
IsType, gridgen
CALLED BY:
RemoteView
PROCEDURE:
Make sure the proper 3D transformation is set up.
The cube drawn extends from 0 to nDim-1 in all three dimensions.
MODIFICATION HISTORY:
Feb-1997, Paul Hick (UCSD)
[Previous]
[Next]
NAME:
RemoteView_CurrentSheet
PURPOSE:
Find the polygons of the currentsheet surface in cartesian coordinates
for a given helographic-sperical B3D matrix.
CATEGORY:
tool
CALLING SEQUENCE:
V = RemoteView_CurrentSheet(FOVInfo, P)
INPUTS:
FOVInfo array[1]; type: structure
structure set up by RemoteView_Init_FOV
B3D array[lng,lat,rad]; type: float
3D magnetic data;
OUTPUTS:
V array[3,*]; type: float
polygon coordinates in rectangular coordinates
Units are data units (usually AU).
P array[*]; type: integer
information about polygons (# points for each polygon,
and index lists for all points in each polygon)
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
AngleRange, BadValue, CV_COORD, IsType, gridgen
CALLED BY:
RemoteView
PROCEDURE:
> Taking a B3D array in heliographic spherical convert to cartesian.
> Create a currentsheet based on B3D information
> Build a contoured surface at that currentsheet out of polygons
> Return the list of vertices and polygon-connectivity
MODIFICATION HISTORY:
OCT-2001, T. Dunn (tdunn@ucsd.edu)
JUL-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Integrated into RemoteView package
[Previous]
[Next]
NAME:
RemoteView_Destroy
PURPOSE:
Clean up heap variables
CATEGORY:
RemoteView package
CALLING SEQUENCE:
RemoteView_Destroy, M3D, V3D, D3D
INPUTS:
M3D array[1]; type: structure
V3D array[1]; type: structure
D3D array[1]; type: structure
OUTPUTS:
(none)
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLED BY:
RemoteView, RemoteView_Init
PROCEDURE:
Destroy heap variables associated with the M3D, V3D and D3D structures
MODIFICATION HISTORY:
JULY-2001, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_Destroy_FOV
PURPOSE:
Clean up heap variables
CATEGORY:
RemoteView package
CALLING SEQUENCE:
RemoteView_Destroy_FOV, FOVInfo
INPUTS:
FOVInfo array; type: structure
array of FOVInfo structures
OUTPUTS:
(none>
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLED BY:
RemoteView, RemoteView_Init
PROCEDURE:
Destroy heap variables associated with FOVInfo.view_elo and FOVInfo.matrix
The FOVInfo structure contains three pointers to heap variables.
FOVInfo.view_elo always needs to be cleared.
FOVInfo.matrix and FOVInfo.matrixb only need to be cleared if they point
to an interpolated matrix (see RemoteView_Init_FOV).
MODIFICATION HISTORY:
JULY-2001, Paul Hick (UCSD/CASS)
JULY-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Updated to handle pointer to magnetic field.
[Previous]
[Next]
NAME:
RemoteView_Display2D
PURPOSE:
Calculates a line-of-sight integration throught the 3D volume data in
FOVCube.
CATEGORY:
RemoteView project
CALLING SEQUENCE:
PRO RemoteView_Display2D, D3D, FOVInfo, FOVCube, FOVLoc, iView, voxel=Voxel, $
f3dfnc=f3dfnc, base_dir=base_dir, base_name=base_name, images=images, $
silent=silent ;, _extra=_extra
INPUTS:
D3D array[1]; type: structure
contains information about volume data (see
RemoteView_Init)
FOVCube array[nX,nY,nZ]; type: float
function values covering fov of nX,nY lines of sight
at nZ positions along line of sight
FOVLoc array[3,nX,nY,nZ]; type: float
heliographic locations at all of the line of sight
segments. Always in spherical coordinates (even for
rectangular matrix) i.e. heliographic longitude,
latitude in radians; and heliocentric distance in AU.
iView scalar; type: integer
image number (used only in file name construction)
OPTIONAL INPUT PARAMETERS:
OUTPUTS:
(images to display or file)
images=images scalar or array; type: string
fully-qualified names of all image files created
(if no image was created, 'images' will be undefined)
base_dir=basedir scalar; type: string; default: getenv('TEMP')
destination directory for all image files
(if the directory images are written to getenv('TEMP'))
INCLUDE:
@compile_opt.pro ; On error, return to caller
EXTERNAL:
ThomsonBrightness
CALLS: ***
BadValue, CONGRID [1], CONGRID [2], CONGRID [3], CheckDir, FILEPATH, InitVar
IntegrateLOS, IsType, LOADCT, REVERSE, SuperArray, ThomsonRadialFilter, TimeString
TimeUnit, UBVConst, WRITE_BMP, WRITE_GIF, WRITE_PPM, WhatIs, bin_write, boost
destroyvar, twin
CALLED BY:
RemoteView
COMMON BLOCKS:
common SkyDisplaySave, PreviousImage
PROCEDURE:
MODIFICATION HISTORY:
JUN-2001, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_Display3D
PURPOSE:
Collapses the 3D volume data in FOVCube to a 2D view ready for display using
some form of rgbo rendering
CATEGORY:
RemoteView project
CALLING SEQUENCE:
RemoteView_Display3D, D3D, FOVinfo, FOVCube, FOVLoc, iView, voxel=Voxel
INPUTS:
D3D array[1]; type: structure
info about volume data (see RemoteView_Init)
FOVCube array[nX,nY,nZ]; type: float
function values covering fov of nX,nY lines of sight
at nZ positions along line of sight
FOVLoc array[3,nX,nY,nZ]; type: float
heliographic locations at all line of sight segments.
Always returned in spherical coordinates (even for
rectangular matrix) i.e. heliographic longitude,
latitude in radians; and heliocentric distance in AU.
iView scalar; type: integer
image number (used only in file name construction)
OPTIONAL INPUT PARAMETERS:
FOVCubeB=FOVCubeB
array[nX,nY,nZ]; type: float
magnetic field values covering fov of nX,nY lines of
sight at nZ positions along line of sight
voxel=Voxel scalar; type: integer; default: 0
0: skip rgbo calculation (bodies and orbits only)
1: use IDL Voxel_Proj function
(doesn't work in IDL 5.4 unless the patch
Voxel_Proj2 is available)
2: home-brew rgbo rendering (needs work)
base_dir=basedir
scalar; type: string; default: getenv('TEMP')
destination directory for all image files
(if the directory images are written to getenv('TEMP'))
logo=logo scalar; type: string; default: none
name of tiny image file to be put in lowerleft corner of
display. Must be a truecolor image.
rim=rim array[4]; type: float; default: [0.0,0.15,0.1,0.1]
OUTPUTS:
(images to display or file)
images=images scalar or array; type: string
fully-qualified names of image files
(if no images were created, 'images' will be undefined)
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CONGRID [1], CONGRID [2], CONGRID [3], CheckDir, FILEPATH, InitVar, IsType, LOADCT
REVERSE, RGBO_DepthCue, RGBO_Project, RemoteView_Matte, Reset_Colors, SuperArray
TimeString, TimeUnit, WRITE_BMP, WRITE_GIF, WRITE_PPM, boost, destroyvar, img_read, twin
CALLED BY:
RemoteView
COMMON BLOCKS:
common SkyDisplaySave, PreviousImage
PROCEDURE:
The common block is used to store the left image when an interleaved
image is requested. (after the right image is calculated the left and
right images are merged).
MODIFICATION HISTORY:
AUG-2000, Paul Hick (UCSD/CASS)
AUG-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Our home-made rgbo rendering engine (voxel=2) seems to work now.
Added option to include depth cueing, and an option to do 'radial
cueing' (multiply opacity with a radial distance-dependent function).
Added color legend to display, together with minimal annotation.
JUN-2004, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
A negative Voxel value now suppresses the labeling and color bar.
[Previous]
[Next]
NAME:
RemoteView_EqTrans
PURPOSE:
Sets integer ID of mapping used to map sky to display
CATEGORY:
RemoteView project
CALLING SEQUENCE:
Result = RemoteView_EqTrans(/eqdistance, /eqangle, /eqarea)
OPTIONAL INPUT PARAMETERS:
/eqdistance preserve distance to line of sight through center of image
(this is the default if no keywords are set)
/eqangle preserve angular distance to line of sight through center of image
/eqarea preserve area on sky;
OUTPUTS:
Result scalar; type: integer
@compile_opt.pro ; On error, return to caller
CALLED BY:
RemoteView_FOV_Edge, RemoteView_FOV_loc, RemoteView_FOV_xyz
RemoteView_Init_View
PROCEDURE:
MODIFICATION HISTORY:
SEP-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_FOV
PURPOSE:
Calculates image of sky from 3D density matrix for a given viewer location
and viewing direction.
CATEGORY:
RemoteView package: Image construction
CALLING SEQUENCE:
Status = RemoteView_FOV(V3D, M3D)
INPUTS:
V3D array[1]; type; structure
structure array containing information about the views
to be calculated.
M3D array[1]; type: structure
structure containing 3D density matrices and associated
information; passed to RemoteView_Init_FOV
OPTIONAL INPUT PARAMETERS:
view_index=view_index
scalar; type: integer
index of a single view to be processed
/silent suppress informational messages
OUTPUTS:
FOVCube array[nDim[0],nDim[1],nDim[2],nView]
Output matrix with interpolated data values.
This is the matrix that needs to be integrated along the 3rd
(line-of-sight) dimension to create the 2D sky image
FOVInfo array[nView]; type: structure
structure array combining information about a the 3D density
matrices for all views.
FOVLoc array[3,nDim[0],nDim[1],nDim[2]]; type: float
(only returned when 'view_index' is specified)
heliographic locations at all of the line of sight segments.
Always returned in spherical coordinates (even for rectangular
matrix) i.e. heliographic longitude, latitude in radians; and
heliocentric distance in AU.
FOVCubeB = FOVCubeB
array[nDim[0],nDim[1],nDim[2],nView]
Output matrix with interpolated data values for magnetic field.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
InitVar, IsType, RemoteView_FOV_Cube, RemoteView_Init_FOV, SuperArray, TimeString
TimeSystem, TimeUnit, destroyvar
CALLED BY:
RemoteView, RemoteView_Init
PROCEDURE:
The FOVCube matrix is set up as a float array using the sizes of the two input
structures.
For each view Sky_Grid_Struct is called, returning a new structure combining
all the necessary information (3D density matrix and view).
RemoteView_FOV_Cube does the actual actual calculation; its output is used to fill the
FOVCube array.
MODIFICATION HISTORY:
DEC-2000, Paul Hick (UCSD/CASS)
OCT-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Added keyword /silent
[Previous]
[Next]
NAME:
RemoteView_FOV_Cube
PURPOSE:
CATEGORY:
3D viewing
CALLING SEQUENCE:
Status = RemoteView_FOV_Cube(FOVInfo, FOVCube, R=R, bcube=BCube)
INPUTS:
FOVInfo array[1]; type: structure
OUTPUTS:
status 0: no data inside field of view for specified viewing direction
1: there are data inside the field of view
FOVCube array[nX,nY,nZ]; type: float
function values covering fov of nX,nY lines of sight
at nZ positions along line of sight
OPTIONAL OUTPUT PARAMETERS:
R=R array[3,nX,nY,nZ]; type: float
heliographic locations at all of the line of sight segments.
Always returned in spherical coordinates (even for rectangular
matrix) i.e. heliographic longitude, latitude in radians; and
heliocentric distance in AU.
bcube=BCube array[nX,nY,nZ]; type: float
function values for magnetic field covering fov of nX,nY lines of sight
at nZ positions along line of sight
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
AngleRange, CV_COORD, CvT3d, Elongation, RemoteView_FOV_xyz
CALLED BY:
RemoteView_FOV
PROCEDURE:
> Read the RemoteView document (in D:\work\doc\remoteview.doc) for a detailed description.
> The 3D data set is specified in an arbitrary Cartesian coordinate
system x-y-z.
> The data set is contained within a sphere of radius DataRadius centered
on the origin.
> Put a rectangle with sides 2*tan(FOVInfo.view_fov) in a plane perpendicular
to the viewer direction at a distance of one unit. Define a rectangular grid
of dimension nX x nY covering the rectangle. Connect the origin with each of
the nX x nY grid points to define an angular grid.
> Define a radial grid of dimension nZ extending outward from the
observer between FOVInfo.view_extent[0] and FOVInfo.view_extent[1].
> The radial and angular grid define a 'sky grid' covering the portion of
space along the viewing direction which may contain data.
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS)
DEC-1998, Paul Hick (UCSD/CASS, pphick@ucsd.edu), rewrite
[Previous]
[Next]
NAME:
RemoteView_FOV_Edge
PURPOSE:
CATEGORY:
RemoteView project
CALLING SEQUENCE:
fovedge = RemoteView_FOV_Edge(fov, EqTrans)
INPUTS:
fov scalar; type: float
half-width of field of view (radians)
EqTrans scalar; type: integer
defines the type of transformation between fov and sky.
OUTPUTS:
fovedge scalar; type: float
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
RemoteView_EqTrans
CALLED BY:
RemoteView_FOV_loc, RemoteView_FOV_xyz
PROCEDURE:
MODIFICATION HISTORY:
DEC-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_FOV_loc
PURPOSE:
CATEGORY:
3D viewing
CALLING SEQUENCE:
FUNCTION RemoteView_FOV_loc, vector, FOVInfo, rectangular=rectangular, dloc=dloc
INPUTS:
vector array[3,*]; type: float
heliographic coordinates (spherical or, if /rectangular,
Cartesian) of points to be converted to display coordinates.
Distances are in data units (usually AU).
FOVInfo array[1]; type: structure
structure set up by RemoteView_Init_FOV
OPTIONAL INPUT:
/rectangular if set then 'vector' is in rectangular heliographic coordinates
(default is spherical coordinates).
OUTPUTS:
Result arrays[3,*]
input vector points converted to sky coordinates.
These are normal coordinates, i.e. points inside the fov
range from 0 to 1.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
BadValue, CV_COORD, CvT3d, InitVar, RemoteView_EqTrans, RemoteView_FOV_Edge
SyncDims
CALLED BY:
RemoteView
PROCEDURE:
> Read the RemoteView document (D:\work\doc\remoteview.doc) for a detailed description.
> The 3D data set is specified in an arbitrary Cartesian coordinate
system x-y-z.
> The data set is contained within a sphere of radius DataRadius centered
on the origin.
> Put a rectangle with sides 2*tan(Fov) in a plane
perpendicular to the viewer direction at a distance of one unit.
Define a rectangular grid of dimension nDimX x nDimY covering the rectangle.
Connect the origin with each of the nDimX x nDimY grid points to
define an angular grid.
> Define a radial grid of dimension nDimZ covering the range FOVInfo.view_extent
> The radial and angular grid define a 'sky grid' covering the portion of
space along the viewing direction which may contain data.
STRUCTURES:
FOVInfo.view_loc, FOVInfo.view_dir, FOVInfo.view_fov, FOVInfo.view_tilt
FOVInfo.view_eqtrans, FOVInfo.view_extent
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS)
DEC-2000, Paul Hick (UCSD/CASS, pphick@ucsd.edu), rewrite
[Previous]
[Next]
NAME:
RemoteView_FOV_xyz
PURPOSE:
Internal use. Should be called by RemoteView_FOV_Cube only.
CATEGORY:
RemoteView project
CALLING SEQUENCE:
R = RemoteView_FOV_xyz(x, FOVInfo)
INPUTS:
x float array[4,nDimX,nDimY,nDimZ]
Initialized in calling program RemoteView_FOV_Cube with:
x = fltarr(4,nDimX,nDimY,nDimZ, /nozero)
Only x[0:2,*,*,*] is filled here.
FOVInfo array[1]; type: structure
structure set up by RemoteView_Init_FOV
OPTIONAL INPUT PARAMETERS:
/bigmemory if set then no explicit do-loops are used in the calculations.
This will be significantly faster if lots of memory is available
(i.e. as long as no disk swapping is needed)
OUTPUTS:
Result float array[4,nDimX*nDimY*nDimZ]
Cartesian coordinates of locations where interpolated
densities are required. The coordinate system is the X,Y,Z
coordinate system defined in the RemoteView document.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
InitVar, IsType, RemoteView_EqTrans, RemoteView_FOV_Edge, gridgen
CALLED BY:
RemoteView_FOV_Cube, RemoteView_Init_FOV
PROCEDURE:
If the output array is reformed to Result[4,nDimX,nDimY,nDimZ] then the nDimX and
nDimY dimensions cover field of view. The nDimZ dimension is the 'depth' dimension.
It stores the distance to the viewer location starting at the maximum distance from
the viewer, i.e. R[*,*,*,0] is the depth layer farthest away from the viewer along
the line of sight; R[*,*,*,nDimZ-1] is closest to the viewer.
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS, pphick@ucsd.edu)
DEC-2000, Paul Hick (UCSD/CASS, pphick@ucsd.edu), adapted for handling of
time-dependent tomography
[Previous]
[Next]
NAME:
RemoteView_FovTilt
PURPOSE:
Good question
CATEGORY:
RemoteView project
CALLING SEQUENCE:
R = RemoteView_FovTilt(TT, Pos, /degrees)
INPUTS:
TT array[1] or array[K]
Pos array[2] or array[2,K]
OPTIONAL INPUT PARAMETERS:
/degrees if set all angles are in degrees (default is radians)
OUTPUTS:
R array[2,K]
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CvSky, ToRadians
CALLED BY:
RemoteView_Init_View
PROCEDURE:
MODIFICATION HISTORY:
MAR-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_Init
PURPOSE:
Sets up structure for volume data and viewing information
CATEGORY:
Volume rendering
CALLING SEQUENCE:
RemoteView_Init, M3D, V3D, D3D [, lots of keywords ]
OPTIONAL INPUT PARAMETERS:
/silent controls display of messages
/getcube
if set, only the volume data array FOVCube is returned.
None of the structures will exist on return.
Keywords defining the volume data (passed to RemoteView_Init_Matrix)
f3dmat
b3dmat
matrix_time
matrix_rect
volsize
start_lng
degrees
cme
Keywords passed to RemoteView_Init_View are explained there:
degrees
view_rect
ecliptic
location
direction
view_time
fovsize
fovtilt
stereo
ngrid
eqdistance
eqangle
eqarea
Keywords passed to RemoteView_Init_Display are explained there:
xysize
gif
tiff8
tiff24
bmp8
bmp24
interleave
probe
helios
twinsc
spgreen
spred
earth
rotation (????)
Keywords passed to RemoteView_rgbo are explained there:
full_color,
full_opacity
mid_range
mid_color
mid_opacity
opacity_power
update
rotation=Rotation scalar; type: float
The value of Rotation is used in three ways:
1. the fractional part is used to set the starting heliographic longitude,
e.g. 1884.0 starts at 0 degrees; 1884.25 at 270 degrees.
2. if the image time in the States array is set to !values.f_nan, it is
assumed to be the time at which the longitude corresponding to 'Rotation'
crossed the central meridian (i.e. it is set to CarringtonT(Rotation))
3. Rotation is passed to ReadSynopticMap to read in a map to be wrapped around
the surface of the Sun
OUTPUTS:
M3D array[1]; type: structure
contains information about volume data
V3D array[1]; type: structure
contains information about view
D3D array[1]; type: structure
contains information about display
OPTIONAL OUTPUT PARAMETERS:
fovcube = FOVCube
4-dim array; type: float
Output only when /getcube is set. Contains the volume data
for all views.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
InitVar, IsType, RemoteView_Destroy, RemoteView_Destroy_FOV, RemoteView_FOV
RemoteView_Init_Display, RemoteView_Init_Matrix, RemoteView_Init_View
CALLED BY:
RemoteView
PROCEDURE:
The structures are actually set up by the RemoteView_Init_* functions. This procedure just
functions as a wrapper to keep everything in one place.
MODIFICATION HISTORY:
APR-2001, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_Init_Display
PURPOSE:
Set up the SKY_DISPLAY3D structure.
CATEGORY:
RemoteView project
CALLING SEQUENCE:
FUNCTION RemoteView_Init_Display, fminmax, $
xysize = xysize , $
binary = Binary , $
tiff8 = Tiff8 , $
tiff24 = Tiff24 , $
bmp8 = Bmp8 , $
bmp24 = Bmp24 , $
gif = Gif , $
ppm = Ppm , $
png = Png , $
jpg = Jpg , $
interleave = Interleave, $
body = body , $
rotation = Rotation , $
spgreen = SPGreen , $
spred = SPRed , $
full_range = full_range, $
mergehcs = mergehcs , $
tinysize = tinysize , $
_extra = _extra
INPUTS:
fminmax array[2]; type: float
used if 'full_range' not specified. Typically, this
is set to minimum and maximum of the volume data by
the calling procedure (e.g. RemoteView_Init).
OPTIONAL INPUT PARAMETERS:
full_range=full_range
scalar or array[2]; type: any; no default
(MUST be specified)
A scalar is interpreted as [0,full_range]
The full range of values of rendered data in data
units. These keywords is processed by
RemoteView_rgbo and are after return stored
in the output structure.
xysize = xysize scalar or array[2]; default: [400,400]
dimension of plot window and z-buffer
/tiff8, /tiff24, /bmp8, /bmp24, /gif, /ppm, /png
if one of these is set then the image is build in the
z-buffer and then written to the appropriate image file.
/binary
writes a binary file
/interleave
body=body array; type: string; default: ['Sun','Earth&']
names of bodies to be embedded in the display
names can be any of the bodies from the JPL ephem
(see jpl_body), one of the USNO asteroids
(see usno_body), a body for which ephemerides
are available from the Minor Planet Center (see
mpc_body), or one of
'Helios 1','Helios 2','Fire','SMEX','Stereo-E','Stereo-W'
If the symbol '&' is tag on the end of the name the orbit
is also embedded. This does not work for the spacecraft.
If the symbol '@' is added then a map is wrapped around
the body. This works only for Earth.
rotation=Rotation scalar; type: integer
Rotation is passed to ReadSynopticMap to read in a map
to be wrapped around the surface of the Sun (together
with /spgreen or /spred setting).
/spgreen, /spred if set then this can be used to select the Sac Peak
green or red line map for the rotation set with keyword
Rotation.
OUTPUTS:
S array[1]; SKYVIEW_DISPLAY structure
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
FILEPATH, InitVar, READ_BMP, ReadSynopticMap, RemoteView_Colors
RemoteView_VertexSphere, RemoteView_rgbo, big_body, jpl_body
CALLED BY:
RemoteView_Init
PROCEDURE:
The SKY_DISPLAY3D structure contains information which does not depend on
the viewing location and direction (mainly which celestial bodies to
display).
MODIFICATION HISTORY:
JUN-2000, Paul Hick (UCSD/CASS)
DEC-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu), adapted for handling of
sequence of matrices from time-dependent tomography.
JUN-2004, Paul Hick (UCSD/CASS)
Added markorbit to contol plotting of planetary orbits
OCT-2006, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Added /linear, /neat, /bradley
[Previous]
[Next]
NAME:
RemoteView_Init_FOV
PURPOSE:
Set up structure for RemoteView_FOV
CATEGORY:
RemoteView project
CALLING SEQUENCE:
FOVInfo = RemoteView_Init_FOV(iT, V3D, M3D)
INPUTS:
iT scalar; type: integer
counter for current view (as index into V3D)
V3D array[1]; type; structure
structure array containing information about the views
to be calculated.
M3D array[1]; type: structure
structure containing 3D density matrices and associated
information; passed to Sky_Grid_Struct
OUTPUTS:
FOVInfo array[1]; type: structure
structure combining information about a single 3D density
matrix and a single view. The single density matrix and
view are derived from the two input structure arrays.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
AlignHeliosphere, CV_COORD, Elongation, EulerRotate, RemoteView_FOV_xyz, TimeOp
TimeUnit
CALLED BY:
RemoteView_FOV
RESTRICTIONS:
The interpolation scheme assumes that the matrices are sorted into
chronological order.
PROCEDURE:
> The time for view iT is compared with the matrix times. A new matrix is
calculated by interpolating between two matrices.
> If the view time coincides exactly with a matrix time then no
interpolation is needed. In this case the FOVInfo structure will just
point to the appropriate original matrix.
> If only one matrix is specified then this matrix is always used (i.e.
the specified times are ignored.
> The V3D and M3D contain information about ALL views and ALL matrices,
respectively. The SKYVIEW_FOV structure is assembled from the two
structures and describes a single view and matrix.
matrix This is a pointer to a 3D density matrix
matrix_index Time index into 3D matrix (=0 for interpolated matrix)
matrix_rect Set to 1 for rectangular matrix
matrix_rEdge Inner and outer radius of data (AU)
matrix_dR AU/grid spacing
matrix_Origin Location of origin (grid spacings; only for rectangular data)
matrix_lng0 Start heliographic longitude of matrix
view_loc Viewing location : lng, lat in radians; distance in AU
view_dir Viewing direction: lng, lat in radians
view_fov Angular half-width field of view (radians)
view_tilt Field of view tilt angle (radians)
view_ndim Dimensions of field of view cube
view_eqtrans
view_extent Minimum, maximum distance along line of sight
view_elo Elongation across field of view
MODIFICATION HISTORY:
DEC-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_Init_Matrix
PURPOSE:
Defines structure for storing 3D matrix and associated information
CATEGORY:
Sky project: structure definition
CALLING SEQUENCE:
M3D = RemoteView_Init_Matrix(f3dmat=F3Dmat, b3dmat=B3Dmat, $
matrix_time=matrix_time, volsize=volsize, start_lng=start_lng, /degrees, /rect)
INPUTS:
F3Dmat array[N,L,M,K]; type: float
array[N,L,M ] (K = 1)
Specifies a sequence of 3D heliospheric volume data to be rendered.
The array must have at 3 or 4 dimensions. The first three are the
spatial dimensions; the last usually is the time dimension. The matrix
can be specified on a Cartesian or a spherical grid, but always refers
to heliographic coordinates:
Each matrix F3Dmat[*,*,*,k] (k=0,K-1) represents a spatial
scalar solar wind quantity at time TT[k].
The matrix covers a whole Carrington rotation (360 degree
in heliographic longitude) starting at longitude start_lng (see below)
Rectangular: N=L=M; cube of data with the location of the Sun
as implied by 'volsize' keyword (see below).
Spherical: N=# longitudes covering 360 deg
L=# latitudes covering -90,90 deg
M=# heliocentric distances covering [volsize[0],volsize[1]]
The Sun is located at radial distance 0.
B3Dmat array[N,L,M,K]; type: float
array[N,L,M ] (K = 1)
Radial component of the magnetic field, corresponding to F3Dmat volume date.
OPTIONAL INPUT PARAMETERS:
Parameters used to define the volume data matrix.
matrix_time=matrix_time
array[1] or array[K]; type: time structure
times for each of the K 3D matrices in F3Dmat
For K=1 no time needs to be specified.
/matrix_rect
if set then F3Dmat refers to a Cartesian (rectangular) coordinate system
(default is a spherical coordinate system).
volsize=volsize
scalar, array[2]; type: float; default: [0,1.5]
A scalar is interpreted as [0,volsize]
Cartesian: volsize[1] is half the size of the cube covered by F3Dmat
(volsize[0] is not used)
Spherical: heliocentric distance range covered by F3Dmat
volsize=volsize
Determines the spatial extent of the volume covered by F3Dmat (in AU).
If tomography files are read then this keyword can be used to limit the extent.
of the volume rendered.
If /matrix_rect NOT set (spherical data set)
scalar or array[2]; type: float; default: [0,1.5]
A scalar is interpreted as [0,volsize].
volsize[0] and volsize[1] are the inner and outer radial boundary of F3Dmat
If /matrix_rect set (rectangular data set)
scalar, array[2], array[3], array[2,3]
volsize determines the edges of the cube in x, y and z dimension, respectively.
-A scalar volsize is interpreted as
[[-volsize,volsize], [-volsize,volsize], [-volsize,volsize]] i.e. the
origin of the coordinate system is in the center of a cube with sides 2*volsize.
- An array[2] is interpreted as
[[-volsize[0],volsize[1]], [-volsize[0],volsize[1]], [-volsize[0],volsize[1]]]
i.e. the volume is a cube with sides volsize[1]-volsize[0], but the origin is
not necessarily in the center.
-An array[3] is interpreted as
[[-volsize[0],volsize[0]], [-volsize[1],volsize[1]], [-volsize[2],volsize[2]]]
i.e. the size of the volume is different for all dimensions, but the
origin is still in the center of the volume.
start_lng=start_lng
scalar or array[K]; type: float: default: 0.0
start heliographic longitude of the matrices in F3Dmat
If K > 1 then start_lng can be an array with different start
longitudes for each of the K matrices in F3Dmat.
(if scalar is used then the same value is used for all K matrices).
/degrees if set then start_lng is assumed to be in degrees.
cme=cme if set then RemoteView_CMEDensity is called to add the density of a CME to
the input F3Dmat density matrix. This is an old trick which superposes
a 3D HELIOS CME density on the input volume data.
if /matrix_rect is set then this keyword is ignored
If /cme is set then:
The CME density matrix is assigned the same time as the matrix time.
The CME is expanded from matrix_time to view_time (usually the view times
will be a couple of days later than the matrix time).
rot_cme are two angles (in radians) used to rotate the CME matrix to
the desired part of the heliosphere
OUTPUTS:
M3D array[1]; type: Sky_Matrix3D structure
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLED BY:
RemoteView_Init
RESTRICTIONS:
For matrices referring to Cartesian coordinates the grid spacings in all three dimensions
must correspond to the same physical distance in AU. So it is not permitted e.g to use
a grid spacing of 0.2 AU for the x-dimension and 0.1 for y and z.
CALLS: ***
AngleRange, BadValue, InitVar, IsType, MEAN, RemoteView_CMEDensity, SuperArray
TimeSystem, ToRadians
PROCEDURE:
> The 3D matrix F3Dmat is specified in a heliographic coordinate system, with
x and y axis in the solar equator and z-axis toward solar north. The Sun is
located in the origin. The heliographic longitude of the x-axis is given by
'start_lng'.
> If only one spatial matrix is specified (i.e. K=1) then the time keyword need not be specified
(unless /cme is set)
> The structure used to carry around information about the 3D matrix.
time array[K] time of matrix (pointer to heap variable)
F3Dmat array[n,m,l,K] the matrix itself (pointer)
Lng0 array[K] heliographic longitude at start of matrix (pointer)
dR float spatial resolution (AU/grid spacing)
rEdge fltarr(2) inner and outer edge (grid spacings)
Origin float(3) location of Sun (grid spacings) (0,0,0) for spherical matrix)
rectangular integer 0: spherical coordinates; 1: Cartesian coordinates
MODIFICATION HISTORY:
MAY-2000, Paul Hick (UCSD/CASS)
DEC-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu), adapted to handle a sequence of
matrices from time-dependent tomography
[Previous]
[Next]
NAME:
RemoteView_Init_View
PURPOSE:
CATEGORY:
CALLING SEQUENCE:
FUNCTION RemoteView_Init_View, $
view_rect = view_rect, $
ecliptic = ecliptic, $
location = location, $
direction = direction, $
time = time, $
view_time = view_time, $
fovsize = FovSize, $
fovtilt = FovTilt, $
degrees = degrees, $
ngrid = nGrid, $
stereo = Stereo, $
eqdistance = EqDistance, $
eqangle = EqAngle, $
eqarea = EqArea, $
earth = Earth, $
silent = silent
OPTIONAL INPUT PARAMETERS:
(only one of location, direction, view_time, fovsize and fovtilt needs to be
specified as an array with trailing dimension K to set up an array of views,
e.g. if the same view is needed for different time then view_time will be an
array[K], while location is an array[3], direction an array[2] and fovsize
and fovtilt are scalars).
/degrees
if set then all angles are in degrees (default is radians)
/view_rect
By default, spherical coordinates are used (longitude, latitude, heliocentric
distance). If /view_rect is set rectangular coordinates.
This applies to Location and Direction
/ecliptic
By default, a heliographic coordinates are used. If /ecliptic is
set an ecliptic coordinate system is used.
This applies to Location, Direction and FovTilt
location = location
array[3] or array[3,K]; type: float
viewing locations
Longitude, latitude, heliocentric distance (if /view_rect NOT set),
or x, y and z coordinates relative to Sun (if /view_rect set).
The distance unit is AU. The unit for angles depends on the /degree setting.
If location is not set then a default location is selected
based on the location of Earth. Currently the default location
has the same ecliptic longitude as Earth, ecliptic latitude
of 30 degrees, and a distance of 3 times the Sun-Earth distance.
If keyword location is also specified then parts of location
that are not set to bad will be inserted in the default viewing
location.
/earth selects the position of Earth as the viewing location
If keyword location is also specified then parts of location
that are not set to bad will be inserted in the viewing
location.
direction = direction
array[2] or array[2,K] (if /view_rect NOT set); type: float
viewing direction for center of field of view as longitude, latitude
and heliocentric distance (in AU)
array[3] or array[3,K] (if /view_rect set); type: float
viewing direction in rectangular coordinates (in AU). Only the direction
will be used.
The direction is specified in the same coordinate system as the viewer
location, but with the viewer in the origin. If no direction is specified
then the direction towards the origin is used.
view_time = view_time
array[1] or array[K]; type: time structure
times for all views; if not specified then keyword 'time' is used;
if this also is not specified the the system time is used.
fovsize = FovSize
scalar, array[2], array[2,K]; type: float
Angular half-widths (horizontal and vertical) of rectangular field of view
If scalar is specified then horizontal and vertical
size are assumed to be the same.
fovtilt = FovTilt
scalar or array[K]; type: float
??? Tilt angle of field of view. Zero tilt means that the horizontal
direction in the image is parallel to the ecliptic or solar
equator (depending on the setting of keyword /ecliptic)
Tilt angle increases counterclockwise.
nGrid = nGrid
scalar or array[3]; type: integer; default: [31,31,31]
dimension of the 3D matrix describing the view. The first and second
dimension is the 'horizontal' and 'vertical' direction in the field of view.
The third is the 'depth' dimension (along the lines of sight)
/stereo
stereo = [Angle,Distance]
/stereo if set, stereo pairs are produced using default
settings for stereo angle (6 degrees) and
distance (Sun-viewer distance)
stereo=[Angle, Distance]
if specified as a two-element array, the first
element is used as stereo angle, the second as
stereo distance. If the distance is set to zero
then the viewer-origin distance Loc[2,*] is used.
/eqdistance preserve distance to line of sight through center of image
/eqangle preserve angular distance to line of sight through center of image
/eqarea preserve area on sky;
OUTPUTS:
Result array[1]; type: SMEIremoteView structure
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
AngleRange, CV_COORD, CvSky, InitVar, IsType, RemoteView_EqTrans, RemoteView_FovTilt
RemoteView_StereoStates, SuperArray, TimeSystem, ToRadians, arg_time, big_eph
jpl_body
CALLED BY:
RemoteView_Init
PROCEDURE:
nview # views
time time structure (pointer)
Loc viewing location: heliographic lng, lat (radians)
and r (AU) (pointer)
Dir viewing direction: heliographic lng, lat (radians)
Fov angular half-width field of view (radians)
Tilt field of view tilt angle (radians)
nDim dimensions of fov cube
rNear AU
eqtrans int scalar 1,2 or 3
1: preserve distance to line of sight through center of image
2: preserve angular distance to line of sight through center of image
3: preserve area on sky;
stereo 0: stereo off; 1: stereo on (with left image in even,
and right image in odd view locations)
silent=silent controls display of informational messages
MODIFICATION HISTORY:
MAY-2000, Paul Hick (UCSD/CASS)
DEC-2000, Paul Hick (UCSD/CASS)
adapted to handle matrix sequences from time-dependent tomography.
NOV-2001, Paul Hick (UCSD/CASS)
fixed bug processing /ecliptic keyword when no viewing location is specified
APR-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
fixed bug processing location when specified explicitly with keyword /ecliptic
JUN-2004, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Made sure that input is converted to double precision to avoid problems
with integer input.
[Previous]
[Next]
NAME:
RemoteView_Matte
PURPOSE:
Sets up the opacity matte values for a volume data set
CATEGORY:
Visualization
CALLING SEQUENCE:
RemoteView_Matte, FOVLoc, depth=depth, far=far, matte=matte
INPUTS:
FOVLoc array[3,n,l,m]; type: float
locations of volume elements in FOVCube in heliographic coordinates
(longitude, latitude, heliocentric distance).
OPTIONAL INPUT PARAMETERS:
cue_radial=cue_radial
array[4]; type: float
[rmin, rmax, depth, depth_power]
If depth_power is not specified then 1.0 is assumed.
Causes an opacity that drops off with distance from from 1 at 'rmin'
to 'depth' at 'rmax'.
The opacity drops off as a power law with power 'depth_power'
(the power should be positive)
OUTPUTS:
matte=matte array[n,l,m]; type: float
opacity matrix (values between 0 and 1)
This matrix is passed to RGBO_Project, where it is multiplied
with the rgbo vector.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
IsType
CALLED BY:
RemoteView_Display3D
PROCEDURE:
This procedures applies modification to the
opacities which depend on location in the volume data (rather than just the
color). The resulting opacities are folded into the rgb color indices
before returning.
MODIFICATION HISTORY:
AUG-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_PlotVertices
PURPOSE:
CATEGORY:
CALLING SEQUENCE:
INPUTS:
OPTIONAL INPUT PARAMETERS:
OUTPUTS:
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
EXTERNAL:
CALLS: ***
RemoteView_VertexSphere, WhatIs, setup3d, twin
SEE ALSO:
COMMON BLOCKS:
SIDE EFFECTS:
RESTRICTIONS:
EXAMPLE:
PROCEDURE:
MODIFICATION HISTORY:
OCT-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_rgbo
PURPOSE:
Sets up the RGBO vector for volume rendering
CATEGORY:
Volume rendering: RemoteView
CALLING SEQUENCE:
rgbo = RemoteView_rgbo, $
rgbo = rgbo, $
rgb_range = rgb_range, $
full_range = full_range, $
full_color = full_color, $
full_opacity = full_opacity, $
mid_range = mid_range, $
mid_color = mid_color, $
mid_opacity = mid_opacity, $
opacity_power = opacity_power, $
update = update, $
postfix = postfix
INPUTS:
full_range=full_range
scalar or array[2]; type: any; no default (MUST be specified)
A scalar is interpreted as [0,full_range]
The full range of values of rendered data in data units
(e.g. cm^-3 for a rendering of densities)
This range is converted to the byte range 'rgb_range' (using bytscl).
OPTIONAL INPUT PARAMETERS:
rgbo=rgbo array[256,4]; type: float
rgbo vector to be updated. If 'rgbo' does not exist and /update
is not set then a new rgbo vector is created.
/update if set then the input rgbo vector is updated
(ignored if rgbo is not defined)
rgb_range = rgb_range
scalar or array[2]; type: byte; default: [0B,255B]
Range of elements in rgbo assigned to the data set.
mid_range = mid_range
scalar or array[2]; type: any; default: full_range
A scalar is interpreted as [0,full_range]
Internally this is restricted to be a subrange of 'full_range'
Range of data values defining 'intermediate data values'
full_color = full_color
scalar or array[2]; default: [0,235]
A scalar is interpreted as [0,full_color].
Range of colors to be used in the rendering.
Internally this is restricted to the available colors (currently 236).
color_range[0] is matched to data value full_range[0]
color_range[1] is matched to data value full_range[1]
mid_color = mid_color
scalar or array[2]; default: full_color
Internally this is restricted to be a subrange of 'full_color'
Range of colors used for rendering the intermediate data values
full_opacity = full_opacity
scalar or array[2]; type: float; default: [0,1]
range of opacity values
mid_opacity = mid_opacity
scalar or array[2]; type: float; default: full_opacity
Internally this is restricted to be a subrange of 'full_opacity'
Opacity applied to data values to mid-range data values
opacity_power = opacity_power
scalar; type: float; default: 1
power applied to opacity for mid-range data values
OUTPUTS:
rgbo array[256,4]; type: float
rgbo color vector needed for volume rendering
The first index [0,255] represent the data values.
Only the range 'rgb_range' is filled. The rest is zero
(if rgbo is created), or unmodified (if rgbo is updated)
The colors values rgbo[0:2,*] are not yet multiplied
with the opacities.
data_range= data_range
array[2], type: float
The actual range of values of rendered data in data units.
This is derived from the input 'full_range'
rgb_index = rgb_index
array[2], type: byte
Actual range of elements in rgbo assigned to the data set.
This is derived from the input 'rgb_range'
INCLUDE:
@compile_opt.pro ; On error, return to caller
@skycolors.pro ; Dummy comment for Linux
CALLS: ***
FILEPATH, InitVar, IsType, SetRange, flt_read, gridgen, who_am_i
CALLED BY:
RemoteView_Init_Display
SIDE EFFECTS:
Needs file remoteview_rgbo.txt, storing the color table information
RESTRICTIONS:
PROCEDURE:
The original 3D matrix will cover a certain range of data values. Volume rendering
can only handle a maximum of 256 different 'density values'.
We first need to decide how many of these 256 colors we want to assign to the
3D density matrix. If only one 3D volume data set is rendered then the full
range [0,255] can be used, but when several 3D volume data sets are merged
each set is assigned its own subrange. This is done with keyword 'rgb_range'
Next we need to set the range of data values in the 3D matrix to be rendered.
'full_range' sets the data range to be scaled to 'rgb_range'. The 3D matrix has
to be converted to byte by the IDL bytscl command (as e.g. in RemoteView_Display3D)
rgb_range[0]+bytscl( Matrix, top=rgb_range[1]-rgb_range[0], min=full_range[0], max=full_range[1])
This scales the data values to the proper range 'rgb_range'
Note that data values below full_range[0] are treated the same as full_range[0], and data
values above full_range[1] the same as full_range[1]).
'mid_range' selects a subrange of 'full_range'. These two values separate the full range
in three sections:
low data values: [full_range[0], mid_range[0]]
intermediate values: [mid_range [0], mid_range[1]]
high data values: [midrange [1], full_range[0]]
These three ranges are treated separately.
To set up the rgbo vector an 8-bit color table and an opacity needs to be defined.
The color table information is stored in two files (see RESTRICTIONS).
Keywords 'full_color' and 'mid_color' select color ranges from this table.
Keywords 'full_opacity' and 'mid_opacity' set the opacities.
Data values, color indices and opacities are matched as follows:
full_range[0] <-----> full_color[0] <------> full_opacity[0]
mid_range [0] <-----> mid_color [0] <------> mid_opacity [0]
mid_range [1] <-----> mid_color [1] <------> mid_opacity [1]
full_range[1] <-----> full_color[1] <------> full_opacity[1]
For the low data values (between full_range[0] and mid_range[1]) both color index
and opacity are obtained by a linear scaling with the data values; the same is
the case for the high data values (between mid_range[1] and full_range[1]).
For the intermediate data values the color index scales linearly with the
data values. The opacity scales as a power law of data value with the power
specified in keyword opacity_power.
MODIFICATION HISTORY:
JUN-2000, Paul Hick (UCSD/CASS)
AUG-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Color table file is now looked for in same directory as
this source code file.
[Previous]
[Next]
NAME:
RemoteView_StereoStates
PURPOSE:
Takes a single viewing state and splits it up into two states
representing a stereo pair
CATEGORY:
Number strangling
CALLING SEQUENCE:
R = RemoteView_StereoStates(nView, TT, Loc, Dir, Fov, Tilt, stereo=Stereo, /degrees)
INPUTS:
TT[n], Loc[3,n], Dir[2,n], Fov[n], Tilt[n]
arrays describing n viewing states (see RemoteView)
/stereo
stereo=[Angle,Distance]
/stereo if set, stereo pairs are produced using default
settings for stereo angle (6 degrees) and
distance (Sun-viewer distance)
stereo=[Angle, Distance]
if specified as a two-element array, the first
element is used as stereo angle, the second as
stereo distance. If the distance is set to zero
then the viewer-origin distance Loc[2,*] is used.
OPTIONAL INPUT PARAMETERS:
/degrees if set, all angles are in degrees (default: radians)
OUTPUTS:
R scalar; type: integer
0 if no stereo states were calculated
1 if stereo states were calculate
OPTIONAL OUTPUT PARAMETERS:
(Only calculated if return value R = 1)
TT[2*n], Loc[3,2*n], Dir[2,2*n], Fov[2,2*n], Tilt[2*n]
The stereo pairs for the n input states are stored as
TT[2*i ] right eye view for state i=0,n-1
TT[2*i+1] left eye view for state i=0,n-1
(Note that TT, Fov and Tilt values will be the
same for left and right view; Loc and Dir will be
slightly different from the input Loc and Dir)
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CV_COORD, EulerRotate, SuperArray, ToRadians
CALLED BY:
RemoteView_Init_View
PROCEDURE:
> Called by RemoteView to set up stereo pairs
In stereo mode each state is split into a stereo pair.
> Coordinate systems are defined in document SkyGrid.doc (probably in D:\work\doc).
> The stereo pair states are defined in the X,Y,Z coordinate system (+Y is the
horizontal direction toward the right). In this coordinate system the viewer
location is at the origin and the viewing direction is the positive Z-axis.
> The stereo pair is defined by two viewing locations close to the origin and
two viewing direction close to the +Z axis.
Take a point P on the +Z axis at distance StereoDist. Take viewing locations
R on the +Y axis and L on -Y axis at equal distance to the origin such that
the lines RP and YP connecting these points to P make an angle StereoAngle
L and R are the positions of left and right eye, respectively.
LP and RP are the viewing directions from left and right eye, respectively.
The separation LR is 2*Dist*tan(StereoAngle/2.)
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS, pphick@ucsd.edu)
MAY-2000, Paul Hick (UCSD/CASS, pphick@ucsd.edu); converted from procedure to function
[Previous]
[Next]
NAME:
RemoteView_VertexMap
PURPOSE:
Map a given synoptic map to a color index range.
CATEGORY:
CALLING SEQUENCE:
FUNCTION RemoteView_VertexMap, Vertex, VMap, Colors, $
polygon=Polygon, scale=Scale, nearestneighbour=NearestNeighbour
INPUTS:
Vertex float array[3,n]
x,y,z coordinates of the vertices of a spherical
polygon surface (as returned by VertexSphere)
VMap array[nLng,nLat]
synoptic map to be mapped to sphere, covering range
[0,360] degrees in longitude, and [-90,90] deg in latitude
OPTIONAL INPUT PARAMETERS:
Colors int array[2]
defines a range of color indices. VMap is rescaled
into the specified color range: the minimum is mapped
to Colors[0], the maximum to Colors[1].
If VMap already is an array of color indices than
this argument can be omitted.
Scale int scalar
use only Scale evenly space colors between
Color[0] and Color[1]
/nearestneighbour if set, the map value at each vertex is calculated by
taking the value of the neares point of VMap.
polygon=Polygon
long array[m]
polygon list for the spherical surface (as returned by
VertexSphere). See IDL Help for shade_volume for
description of the structure of Polygon
OUTPUTS:
Result No polygon array specified:
long array[n] color indices; one for each vertex.
To be used in the 'shade' keyword to polyshade
Polygon array specied:
long array[m] color indices; one for each polygon
To be used in the 'shade_polygon' keyword to polyshade
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CV_COORD, SCALE2LEVELS
CALLED BY:
RemoteView
COMMON BLOCKS:
SIDE EFFECTS:
RESTRICTIONS:
PROCEDURE:
> The synoptic map VMap is 2D array giving function values on a spherical surface
on the regular grid in longitude ([0,360] degrees) and latitude ([-90,90] degrees).
> The Vertex array and Polygon array describe the surface of the sphere in terms
of polygons.
> Function values at the vertices are calculated by interpolation or nearest neighbour
method, and converted to integer color indices, using the round function.
MODIFICATION HISTORY:
[Previous]
[Next]
NAME:
RemoteView_VertexSphere
PURPOSE:
Calulate the vertices for shading a sphere.
CATEGORY:
Skyview package
CALLING SEQUENCE:
RemoteView_VertexSphere, nS, Vertex, Polygon
INPUTS:
nS scalar determines the resolution of the sphere.
25 is a reasonable value
OUTPUTS:
Vertex, Polygon
arrays determined by IDL shade_volume procedure
the vertices are points on the unit sphere,
relative to the origin of the sphere.
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
gridgen
CALLED BY:
RemoteView_Init_Display, RemoteView_PlotVertices
PROCEDURE:
Set up a 3D volume data array containing the distance
to the sphere center. Then calculate the vertex and polygon arrays.
The vertices usually need to be scaled to the appropriate size, and/or
the origin needs to be shifted.
MODIFICATION HISTORY:
FEB-1998, Paul Hick (UCSD/CASS, pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RemoteView_ZEclipticPlane
PURPOSE:
Get coordinate arrays describing ecliptic plane in a Cartesian heliographic
coordinate system.
CATEGORY:
Sky graphics
CALLING SEQUENCE:
ZEcliptic = RemoteView_ZEclipticPlane (TT, X, /corners, angle=Angle, /degrees] )
INPUTS:
TT array[1]; type: standard time structure;
time
X array[2,*]
X and Y coordinates of points in the solar
equatorial plane.
OPTIONAL INPUT PARAMETERS:
/corners if set then only the first 2 points X[*,0:1] are used. The output
arrays will be an array[3,5], in the sequence
(0,0),(1,0),(1,1),(0,1),(0,0), i.e. the Z array can be used to
draw a square representing the ecliptic plane.
/grid if set, every value in X[0,*] is combined with every X[1,*]. This
defines a square grid of points covering the ecliptic plane
angle=Angle scalar; default: 0
the input coordinates are rotated over Angle in the solar
equatorial plane before the Z-coordinates are calculated
/degrees if set, Angle is in degrees (default: radians)
OUTPUTS:
ZEcliptic array[*], array[*,*]
X array[*], array[*,*]
X,Y,Z coordinates of points in ecliptic plane
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CvSky, ToRadians
CALLED BY:
RemoteView
PROCEDURE:
The X-Y-Z coordinate system is associated with heliographic coordinates:
X-Y plane is the solar equator; X-axis has heliographic longitude zero;
Z-axis points to solar North pole.
Ecliptic north has has ecliptic latitude !pi/2 (the longitude doesn't matter,
use 0). Converting this to heliographic coordinates gives the heliographic
longitude, rLng, and latitude, rLat of ecliptic North.
If [A,B,C] is a unit vector pointing to ecliptic north, then
A = cos(rLat)*cos(rLng)
B = cos(rLat)*sin(rLng)
C = sin(rLat)
The equation of the ecliptic plane in heliographic coordinates is given
by the A*x+B*y+C*z=0. So for given x,y: z = -(A*x+B*y)/C
MODIFICATION HISTORY:
28-Feb-1997, Paul Hick (UCSD, pphick@ucsd.edu)
[Previous]
[Next]
NAME:
Reset_Colors
PURPOSE:
Restore fore- and background colors to original values set during IDL startup
CATEGORY:
Annoying
CALLING SEQUENCE:
Reset_Colors
INPUTS:
(none)
OPTIONAL INPUT PARAMETERS:
/reverse if set then fore- and background color are set opposite
to the defaults stored in the common block
OUTPUTS:
(modifies !p.color and !p.background)
CALLS: ***
InitVar
CALLED BY:
Get_Page, RemoteView_Display3D, Set_Page, jpl_test, nagoya_glevel, qGlitch_Show
qImage_cw_Set_Value, smei_sky, vu_earthskymap, vu_get_page, vu_image, vu_insitu
vu_planarcut, vu_solardisk, vu_synopticmap
PROCEDURE:
When set_plot is used to change devices the fore- and background values are
reset to the IDL defaults !p.color=!d.n_colors-1 and !p.background=0.
MODIFICATION HISTORY:
MAR-2000, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RESTORE_SEQUENCE
PURPOSE:
Obsolete name of SMEI_RESTORE.
CALLS: ***
SMEI_RESTORE, smei_msg
MODIFICATION HISTORY:
Make a wrapper for SMEI_RESTORE: 9/8/04; SJT
[Previous]
[Next]
NAME:
RGBO_DepthCue
PURPOSE:
Section headings used to document SMEI IDL code
CATEGORY:
CALLING SEQUENCE:
RGBO_DepthCue, cue_depth=cue_depth, size=sz, dimension=dimension, matte=matte
INPUTS:
cue_depth=cue_depth scalar or array[2]; type: float
scalar is interpreted as [depth,depth]
depth[0]: opacity at maximum depth
depth[1]: power applied to dropoff from minimum to
maximum depth (should be positive)
OPTIONAL INPUT PARAMETERS:
size=sz array; type: integer
IDL size vector for 3D array
only the dimensions sz[1:sz[0]] are used
dimension=dimension array[3]; type: integer
dimensions of 3D array
Either one of these keyword is used to specify the dimensions
of a 3D array [N,L,M]
matte=matte array[N,L,M]; type: float
The matte matrix for the depth cue is multiplied into
the input matte, if it exists
OUTPUTS:
matte=matte array[N,L,M]; type: float
resulting matte matrix (input matte times depth cue matte)
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
IsType, SuperArray
CALLED BY:
RemoteView_Display3D
SEE ALSO:
RGBO_Project
PROCEDURE:
The 3rd dimension of M is taken to be the z-dimension.
m=0 has maximum depth (farthest away from the viewer) and gets opacity
depth[0]. m=M-1 has minimum depth (nearest to the viewer) and gets opacity
of one. The dropoff between the two is given by the power value:
o = depth[0]+(1-depth[0])*( z/(ndim[2]-1) )^depth[1]
The resulting values are constrained to stay between 0 and 1.
MODIFICATION HISTORY:
AUG-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RGBO_Project
PURPOSE:
Merges content of z-buffer with color and opacity array of volume data set
CATEGORY:
CALLING SEQUENCE:
zpix = RGBO_Project(zvol, rgbo, zpix=zpix, zbuf=zbuf, $
bad_data =bad_data , bad_opacity = bad_opacity , $
low_data =low_data , low_opacity = low_opacity , $
high_data=high_data, high_opacity= high_opacity, matte=matte)
INPUTS:
zvol array[N,M,L]; type: byte
byte array for volume data
rgbo array[256,4]; type; float
rgbo vector; rgbo[*,0] = o*r, rgbo[*,1] = o*g, rgbo[*,2] = o*b
rgbo[*,3] = o*255. o = opacity (0 <= o <= 1), r,g,b = red, green
blue color indices (0 <= r,g,b <= 255).
OPTIONAL INPUT PARAMETERS:
zpix=zpix array[n,m]; type: byte
Z-buffer content (the Z-buffer ia a 256-color device)
array[n,m,3]; type: byte
Z-buffer content as true color image
zbuf=zbuf array[n,m]; type: integer
Z-buffer depth array
background=background
scalar; type: byte
background color index in Z-buffer
If not specified then !p.background is used.
array[3]; type: byte
(only if zpix is true color image)
background color rgb values in Z-buffer
ctrgb=ctrgb array[256,3]; type: byte
(only if zpix is 256-color image)
rgb values for color table to be used to interpret zpix
If not specified then the current color table is retrieved
with the IDL tvlct function.
matte=matte array[N,M,L] or array[N,M,L,4]
matrix of values between 0 and 1 to be applied to
zvol after conversion to rgbo values and before projecting onto
the image plane. This can be used e.g. to implement depth cueing.
An array[N,M,L] is applied to each channel (r,g,b,o).
OUTPUTS:
OPTIONAL OUTPUT PARAMETERS:
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
ArrayLocation, CONGRID [1], CONGRID [2], CONGRID [3], InitVar, IsType, SuperArray
CALLED BY:
RemoteView_Display3D
SEE ALSO:
SIDE EFFECTS:
RESTRICTIONS:
PROCEDURE:
MODIFICATION HISTORY:
JUL-2002, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
RotationMeasure
PURPOSE:
Calculates component of vector field n*B along line of sight
CATEGORY:
sat/idl/toolbox/faraday
CALLING SEQUENCE:
FUNCTION RotationMeasure, REarth, R, F, w3darg, $
ut_earth = ut_earth , $
pa_earth = pa_earth , $
elo_earth = elo_earth , $
elo_sun = elo_sun , $
degrees = degrees
INPUTS:
REarth not used
R array[3,N,L,M] heliographic coordinates of points in a 2D grid
of NxL lines of sight with M segments along each
R[0,*,*,*] : heliographic longitude
R[1,*,*,*] : heliographic latitude
R[2,*,*,*] : heliocentric distance (AU)
F array[N,L,M,3] magnetic field vector, multiplied by the
density, in RTN coordinates
w3darg not used
OPTIONAL INPUT PARAMETERS:
/degrees if set all input angles are in degrees
pa_earth array[N,L,M] position angle from ecliptic north
elo_earth array[N,L,M] angle Sun-Earth-LOS segment (i.e. conventional elongation angle)
elo_sun array[N,L,M] angle Earth-Sun-LOS segment
OUTPUTS:
R array[N,L,M] see PROCEDURE
INCLUDE:
@compile_opt.pro ; On error, return to caller
CALLS: ***
CV_COORD, CvSky, CvSky_RTN, EulerRotate, SubArray, ToRadians, scalarproduct
PROCEDURE:
RM = e^3/(2*pi*m^2*c^4) Integral( n_e * H.dl ) radians cm^-2
In Gaussian units:
e = 4.8 x 10^-10 esu
m = 9.1 x 10^-28 gr
c = 3.0 x 10^-10 cm/s
n_e in cm^-3; H in Gauss; dl in cm
RM = 2.6311927 x 10^-17 Integral( n_e x H.dl ) radians cm^-2
The bb3d files contain magnetic field in nT = 10^-5 Gauss
The distance scale for the integration is AU = 1.5 x 10^13 cm
The wavelengths are in the meter range, so we change
to radians m^-2. Multiplying with the resulting
10^-5 x 1.5 x 10^13 x 10^4 = 1.5 x 10^12:
RM = 3.9362082 x 10^-05 Integral( n_e[cm^-3] x H[nT].dl[AU] ) radians m^-2
The quantity returned by this function is the integrand
RM = 3.9362082 x 10^-05 n_e[cm^-3] x H[nT] x (180/pi) degrees m^-2 AU^-1
MODIFICATION HISTORY:
OCT-2006, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
[Previous]
[Next]
NAME:
run_ssw
PURPOSE:
IDL main program to update the SSW help files.
CATEGORY:
www_help
CALLING SEQUENCE:
idl $pro/run_ssw
INPUTS:
(none)
OUTPUTS:
(html files)
CALLS:
www_help_tree
PROCEDURE:
After completion IDL exits again.
MODIFICATION HISTORY:
JAN-2002, Paul Hick (UCSD/CASS)
FEB-2003, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Added www_help_sync.py call
[Previous]
[Next]
NAME:
run_ssw_smei
PURPOSE:
IDL main program to update the SSW help files.
CATEGORY:
www_help
CALLING SEQUENCE:
idl run_ssw_smei
INPUTS:
(none)
OUTPUTS:
(html files)
CALLS:
do_file, www_help_tree
PROCEDURE:
After completion IDL exits again.
MODIFICATION HISTORY:
JAN-2002, Paul Hick (UCSD/CASS)
FEB-2003, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
Added www_help_sync.py call