;+
; NAME:
;	gridgen1d
; PURPOSE:
;	(For internal use by href=gridgen= only)
; CALLING SEQUENCE:
	FUNCTION gridgen1d, nn, unit, $
		origin	= origin, $ 	; Could be time
		edge	= edge	, $
		open	= open	, $
		one 	= one	, $
		range	= range , $ 	; Could be time range
		double	= double
; INPUTS:
;	nn		scalar; type: integer
;				number of elements in grid
; OPTIONAL INPUTS:
;	origin=origin
;			scalar; type: any numerical type
;			the origin is shifted AFTER
;			applying keywords one or range.
;	/open
;	/edge	return edges of bins
;	/one	same as range=[0,1]
;	range=range
;			array[2]; type: any numerical type
;			scale array to this range
;			If range is of type integer then the grid
;			also will be type integer unless integer
;			truncation occurs.
;	/double if set return double precision grid
; INCLUDE:
	@compile_opt.pro		; On error, return to caller
; CALLS:
;	InitVar, IsType
; EXAMPLE:
;	gridgen(5)				= [0,1,2,3,4]
;	gridgen(5,/open) 		= [0.5,1.5,2.5,3.5,4.5]
;	gridgen(5,/open,/edge)	= [0,1,2,3,4,5]
;	gridgen(5,/one) 		= [0.0,0.25,0.5,0.75,1.0]
;	gridgen(5,/one,orig=0.5)= [-0.5,-0.25,0.0,0.25,0.5]
; PROCEDURE
;	Sets up 1-dim grid. BE CAREFUL MIXING KEYWORDS.
; MODIFICATION HISTORY:
;	OCT-2000, Paul Hick (UCSD/CASS)
;	SEP-2006, Paul Hick (UCSD/CASS)
;		If range is specified as integer then the return
;		array is returned as integer array also, after
;		checking that integer truncation has not occurred.
;		Keyword origin is now applied after processing
;		keywords one and range (if present).
;	JUN-2008, Paul Hick (UCSD/CASS)
;		Added code to handle n=1 without error messages
;	OCT-2008, Paul Hick (UCSD/CASS; pphick@ucsd.edu)
;		Added code to create 1-d time grids
;-

InitVar, open	, /key
InitVar, edge	, /key
InitVar, one	, /key
InitVar, double	, /key
has_range = IsType(range, /defined)
range_is_time = IsTime(range)

CASE double OF
0: BEGIN
	half  = 0.5
	whole = 1.0
	IF has_range THEN $
		IF NOT range_is_time THEN $
			whole = 1+0*range[0]; integer 1 if range is integer
ENDCASE
1: BEGIN
	half  = 0.5d0
	whole = 1.0d0
END
ENDCASE

; Nr of elements in grid.
; Add extra elements if /open and/or /edge are set

n = nn+open+edge

r = lindgen(n)				; Start with long integer array

; /open set: subtract half a bin and drop the first element

IF open THEN r = r[1:*]-half

; /edge set: subtract half a bin, but keep the extra bin

IF edge THEN r -= half

n -= edge

; If both /open and /edge are set we are back
; at integer indices. Explicitly change type to long integer

IF open AND edge THEN r = round(r)

CASE 1 OF

one: IF n GT 1 THEN r /= n-whole		; Range [0,1]

range_is_time: BEGIN

	InitVar, unit, TimeUnit(/day)

	IF n GT 1 THEN BEGIN
		ds = (TimeOp(/subtract,range[1],range[0],unit))/(n-whole)
	ENDIF ELSE	$
		ds = 0

	r = TimeOp(/add,range[0],TimeSet(/diff,ds*r,unit))

END

has_range: BEGIN

	; If range is input as an integer array we also try to
	; return an integer grid. Note that 'whole' was set to
	; integer 1 if range is an integer.

	; We want an equal-spaced grid.
	; Make sure that an integer grid spacing is what we expect.
	; If the integer divide messes things up, use a float spacing

	IF n GT 1 THEN BEGIN
		ds = (range[1]-range[0])/(n-whole)
		IF IsType(ds,/generic_int) AND ds*(n-whole) NE range[1]-range[0] THEN $
			ds = (range[1]-range[0])/(n-1.0)
	ENDIF ELSE	$
		ds = 0

	r = range[0]+ds*r

END

IsType(unit,/defined): r = TimeSet(/diff,r,unit)

ELSE:			; Nothing to do

ENDCASE

; Shift origin

CASE 1 OF
IsTime(origin)			: r = TimeOp(/subtract,r,origin)
IsType(origin,/defined) : r -= origin
ELSE:
ENDCASE

RETURN, r  &  END