;+
; NAME:
;	vu_get
; PURPOSE:
;	Extract information from headers produced by tomography programs
; CATEGORY:
;	sat/util/vupack
; CALLING SEQUENCE:
	FUNCTION vu_get, hdr,					$
		file			= file			,	$
		created			= created		,	$
		bad				= bad			,	$
		version			= version		,	$
		prefix			= prefix		,	$

		time_index		= time_index	,	$
		uttime			= uttime		,	$

		forecast_time	= forecast_time	,	$

		array_range		= array_range	,	$
		roi_range		= roi_range		,	$

		latitude_range	= latitude_range,	$

		start_distance	= start_distance,	$
		stop_distance	= stop_distance ,	$
		distance_step	= distance_step	,	$

		start_time		= start_time	,	$
		time_step		= time_step		,	$

		power_density	= power_density	,	$
		power_distance	= power_distance,	$
		density_at_1AU	= density_at_1AU,	$
		smooth_filter	= smooth_filter	,	$
		fill_filter		= fill_filter	,	$
		time_filter 	= time_filter	,	$

		clip_longitude	= clip_longitude,	$
		scale			= scale			,	$
		power_norm		= power_norm	,	$
		nlng			= nLng			,	$
		nlat			= nLat			,	$
		nrad			= nRad			,	$
		ntim			= nTim			,	$

		dimension		= dimension		,	$
		iteration		= iteration		,	$

		nltot			= nltot			,	$
		nlos			= nlos			,	$
		dlos			= dlos			,	$
		binx			= binx			,	$

		user_info		= user_info		,	$

		marker			= marker		,	$
		plasma			= plasma		,	$
		magnetic		= magnetic		,	$

		all_radii		= all_radii		,	$
		start_lng		= start_lng 	,	$

		degrees			= degrees
; INPUTS:
;	hdr			array[n]; array of headers extracted from tomography files
; OPTIONAL INPUT PARAMETERS:
;	The output R depends on the keyword set:
;
;	Keyword:			Return values:
;
;	/file				scalar; type: string; fully-qualified file name
;	/created			scalar; type: string; time at which file was created
;	/bad				scalar; type: float; value reprenting 'bad' data
;	/version			scalar; type: string; version number for header layout
;	/time_index
;	/uttime
;	/forecast_time
;	/array_range
;	/roi_range
;	/latitude_range
;	/start_distance
;	/stop_distance
;	/distance_step
;	/start_time
;	/time_step
;	/power_density
;	/power_distance
;	/density_at_1AU
;	/smooth_filter
;	/fill_filter
;	/time_filter
;	/clip_longitude
;	/scale				array[4]; type: float; scaling factors
;	/power_norm			array[2]; type: float
;	/nlng				scalar; type: integer; longitudinal dimension
;	/nlat				scalar; type: integer; latitudinal dimension
;	/nrad				scalar; type: integer; radial dimension
;	/ntim				scalar; type: integer; time dimension
;	/dimension			array[4]; type: integer; # longitudes, latitudes, distances and times
;	/iteration
;	/nltot				array[2]; type: integer; # lines of sight
;	/nlos				array[2]; type: integer, # line-of-sight segments
;	/dlos				array[2]; type: float; length of line-of-sight segment
;	/binx				array[2]; type: float; # line-of-sight segments per bin threshold
;	/user_info
;	/marker
;	/plasma				scalar; type: integer: 1 for velocity/density data
;	/magnetic			scalar; type: integer; 1 for magnetic field data
;
;	/all_radii			array[nRad]; type: float; array of heliocentric distances for hdr[0] only
;	/start_lng			scalar; type: double: heliographic longitude at start of ROI
;
;	/degrees
; OUTPUTS:
;	R	requested entry from header
; INCLUDE:
	@compile_opt.pro					; On error, return to caller
; CALLS:
;	gridgen, ToDegrees
; SEE ALSO:
;	t3d_get, t3d_iget
; MODIFICATION HISTORY:
;	JUL-2001, Paul Hick (UCSD/CASS)
;	SEP-2006, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
;		Added start_lng keyword
; PROCEDURE:
;-

IF keyword_set(file				) THEN RETURN, hdr.file
IF keyword_set(created			) THEN RETURN, hdr.created
IF keyword_set(bad				) THEN RETURN, hdr.bad
IF keyword_set(version			) THEN RETURN, hdr.version
IF keyword_set(prefix			) THEN RETURN, hdr.prefix

IF keyword_set(time_index		) THEN RETURN, hdr.time_index

IF keyword_set(uttime			) THEN RETURN, reform(hdr.uttime)
IF keyword_set(forecast_time	) THEN RETURN, reform(hdr.time_forecast)
IF keyword_set(array_range		) THEN RETURN, hdr.array
IF keyword_set(roi_range		) THEN RETURN, hdr.roi

IF keyword_set(latitude_range	) THEN RETURN, hdr.latitude_range/ToDegrees(degrees=degrees)

IF keyword_set(start_distance	) THEN RETURN, hdr.distance_start
IF keyword_set(stop_distance	) THEN RETURN, hdr.distance_start+(hdr.nRad-1)*hdr.distance_step
IF keyword_set(distance_step	) THEN RETURN, hdr.distance_step

IF keyword_set(start_time		) THEN RETURN, hdr.time_start
IF keyword_set(time_step		) THEN RETURN, hdr.time_step

IF keyword_set(power_density	) THEN RETURN, hdr.power_density
IF keyword_set(power_distance	) THEN RETURN, hdr.power_distance

IF keyword_set(density_at_1AU	) THEN RETURN, hdr.density_at_1AU

IF keyword_set(smooth_filter	) THEN RETURN, hdr.smooth_filter
IF keyword_set(fill_filter		) THEN RETURN, hdr.fill_filter
IF keyword_set(time_filter		) THEN RETURN, hdr.time_filter

IF keyword_set(clip_longitude	) THEN RETURN, hdr.clip_longitude

IF keyword_set(scale			) THEN RETURN, hdr.scale
IF keyword_set(power_norm		) THEN RETURN, hdr.r_pwr

IF keyword_set(nlng				) THEN RETURN, hdr.nLng
IF keyword_set(nlat				) THEN RETURN, hdr.nLat
IF keyword_set(nrad				) THEN RETURN, hdr.nRad
IF keyword_set(ntim				) THEN RETURN, hdr.nTim

IF keyword_set(iteration		) THEN RETURN, [hdr.iteration, hdr.niterations]

IF keyword_set(nltot			) THEN RETURN, hdr.nl
IF keyword_set(nlos				) THEN RETURN, hdr.nlos
IF keyword_set(dlos				) THEN RETURN, hdr.dlos
IF keyword_set(binx				) THEN RETURN, hdr.binx

IF keyword_set(user_info		) THEN RETURN, hdr.user_info
IF keyword_set(marker			) THEN RETURN, hdr.marker
IF keyword_set(plasma			) THEN RETURN, hdr.plasma
IF keyword_set(magnetic			) THEN RETURN, hdr.magnetic

IF keyword_set(dimension		) THEN RETURN, [hdr.nLng, hdr.nLat, hdr.nRad, hdr.nTim]
IF keyword_set(all_radii		) THEN	$
	RETURN, gridgen(hdr[0].nRad, range=hdr[0].distance_start+[0,hdr[0].nRad-1]*hdr[0].distance_step)

IF keyword_set(start_lng		) THEN RETURN, (ceil(hdr.roi[0])-hdr.roi[0])*(360.0d0/ToDegrees(degrees=degrees))

END