This page was created by the IDL library routine mk_html_help2.

Last modified: Wed Jun 24 12:41:17 2009.


Directory Listing of Routines


Routine Descriptions

TCROSSP

[Next Routine] [List of Routines]
PROCEDURE: TCROSSP
Purpose:
  Vectorized routine to calculate the cross product of two tplot
  variables containing arrays of 3d vectors and storing the result
  in a tplot variable

Arguments: 
 v1: The name of the tplot variable storing the first vector in the cross product
 v2: The name of the tplot variable storing the second vector in the
 cross product
 
 newname(optional): the name of the output tplot variable

 error(optional): named variable in which to return error state of
 the computation.  1 = success 0 = failure

NOTES: 

(See ssl_general/cotrans/special/tcrossp.pro)


TDOTP

[Previous Routine] [Next Routine] [List of Routines]
PROCEDURE: TDOTP
Purpose:
  Vectorized routine to calculate the dot product of two tplot
  variables containing arrays of vectors and storing the results
  in a tplot variable

Arguments: 
 v1: The name of the tplot variable storing the first vector in the dot product
 v2: The name of the tplot variable storing the second vector in the
 dot product
 
 newname(optional): the name of the output tplot variable

 error(optional): named variable in which to return the error state
 of the computation.  1 = success 0 = failure

NOTES: 

(See ssl_general/cotrans/special/tdotp.pro)


TINTERPOL_MXN

[Previous Routine] [Next Routine] [List of Routines]
Function: tinterpol_mxn

Purpose:  Generalized interpolates across a series of vectors(since
interpol only works on 1-d vectors) This function works on any
n-dimensional vectors. Basically, this is an element by element
interpolation across M

 - i. works on tplot variables
     - ii. allows no extrapolation beyond valid data with
          /no_extrapolate keyword"
              
Arguments:
            xv_tvar = tplot variable to be interpolated, the y component
            can have any dimesions, can use globbing to interpolate
            many values at once
            uses x component for x abcissa values
            
            uz_tvar = tplot variable that V will be fit to
            uses x component for u abcissa values.  Can also
            pass in an array of time values rather than a tplot 
            variable.
            
            newname = output variable name(optional) defaults to
            xv_tvar+'_interp'
            
            suffix = a suffix other than interp you can use,
            particularily useful when using globbing
            
            overwrite=set this variable if you just want
            the original variable overwritten instead of using
            newname or suffix

            Use only newname or suffix or overwrite. If you combine
            them the naming behavior may be erratic

            /LINEAR = pass this argument to specify linear
            interpolation(this is the default behavior)
            
            /QUADRATIC = pass this argument to specify quadratic
            interpolation
            
            /SPLINE = pass this argument to specify spline
            interpolation
            
            /NO_EXTRAPOLATE = pass this argument to prevent
            extrapolation of data values in V passed it's start and
            end points
            
            /NAN_EXTRAPOLATE = pass this argument to extrapolate past
            the endpoints using NaNs as a fill value

            ERROR(optional): named variable in which to return the error state
            of the computation.  1 = success 0 = failure


CALLING SEQUENCE;
           tinterpol_mxn,'tplot_var1','tplot_var2',out_var='tplot_var_out'
           tinterpol_mxn,'tplot_var1','tplot_var2',/NO_EXTRAPOLATE
           tinterpol_mxn,'tplot_var1','tplot_var2',/SPLINE
         
Output: an N by D1 by D2 by ... array stored in an output tplot variabel

Notes: 
Uses a for loop over D1*D2*..., but I'm operating under the assumption that
D1*D2... << M (D1 * D2 *... is waaaay less than M)

It uses a little bit of modular arithmatic so this function is
generalized to any array dimensionality(IDL limits at 8)


Examples:
 if the input is an array of 3-d vectors(say 1,1,1 and 2,2,2) and we
 want 3 vectors out the output is 1,1,1 1.5 1.5 1.5 2,2,2
 if the input is an array of 3x3 matrices(say all ones and all twos) 
 and we want three matrices then output is all 1s all 1.5s all 2s 
 

 $LastChangedBy: pcruce $
 $LastChangedDate: 2008-12-05 09:42:42 -0800 (Fri, 05 Dec 2008) $
 $LastChangedRevision: 4106 $
 $URL: svn+ssh://thmsvn@ambrosia.ssl.berkeley.edu/repos/ssl_general/tags/tdas_5_1/cotrans/special/tinterpol_mxn.pro $

(See ssl_general/cotrans/special/tinterpol_mxn.pro)


TNORMALIZE

[Previous Routine] [Next Routine] [List of Routines]
PROCEDURE: TNORMALIZE
Purpose:
  Vectorized routine to normalize all the vectors stored in a tplot
  variable


Arguments: 
 v: The name of the tplot variable storing the vectors to be
 normalized
 newname(optional): The name of the output tplot variable. Defaults
 to v+'_normalized'
 error(optional): Named variable in which to return the error state
 of the computation, 1 = success, 0 = failure
 

NOTES:

 $LastChangedBy: bckerr $
 $LastChangedDate: 2008-07-31 16:52:00 -0700 (Thu, 31 Jul 2008) $
 $LastChangedRevision: 3322 $
 $URL: svn+ssh://thmsvn@ambrosia.ssl.berkeley.edu/repos/ssl_general/tags/tdas_5_1/cotrans/special/tnormalize.pro $

(See ssl_general/cotrans/special/tnormalize.pro)


TVECTOR_ROTATE

[Previous Routine] [List of Routines]
Procedure: tvector_rotate

Purpose:  rotates a set of vectors by a set of coordinate
          transformation matrices inputs and outputs are tplot
          variables.  This is designed mainly for use with
          fac_matrix_make.pro and minvar_matrix_make, but can be used
          for more general purposes

Warning:
 The transformation matrices generated by
fac_matrix_make,thm_fac_matrix_make, and minvar_matrix_make are
defined relative to a specific coordinate system.  This means that if
you use vectors in one coordinate system to generate the rotation
matrices they will only correctly transform data from that coordinate
system into the functional coordinate system.  For example if you use
magnetic field data in gsm to generate Rgeo transformation matrices
using fac_matrix_make then the vectors being provided to tvector
rotate to be transformed by those matrices should only be in gsm coordinates.


Arguments:

 mat_var_in: the name of the tplot variable storing input matrices
 The y component of the tplot variable's data struct should be
 an Mx3x3 array, storing a list of transformation matrices. 
 

 vec_var_in: the name of the tplot variable storing input
vectors. You can use globbing to rotate several tplot variables
storing vectors with a single matrix. The y component of the tplot variable's
 data struct should be an Nx3 array.  



 newname(optional): the name of the output variable, defaults to 
                    vec_var_in + '_rot'
                    If you use type globbing in the vector variable
                    This option will be disabled

 error(optional): named variable in which to return the error state
 of the computation.  1 = success 0 = failure


CALLING SEQUENCE:

 tvector_rotate,'matrix_var','vector_var',newname = 'out_var',error=error

 tvector_rotate,'matrix_var','vector_var'

Notes: 
   mat_var_in should store rotation matrices.  (ie the columns of any
   matrix in mat_var_in should form an orthonormal basis)

   If M!=N M must be >= 2 (where M,N refer to the dimensions of the
   input variables.

   Also If the x components of mat_var_in and vec_var_in data structs
   do not match then. The matrices will be interpolated to match the
   cadence of the vector data.  Interpolation is done by turning the
   matrices into quaternions and performing spherical linear
   interpolation.  As noted above this interpolation behavior will
   not be predictable if the matrices do anything other than rotate.

   The user should note that if the timestamps of mat_var_in are not
   monotonic(ascending or identical) or if the timestamps vec_var_in are not strictly
   monotonic(always ascending) the program will not work correctly.  It is the user's 
   responsibility to remove duplicate or non sequential timestamps from the data 

   PROGRAMMERS: you might want to consider adding a check to 
   verify that input matrices are actually rotation matrices
   this would just verify that M dot transpose(M) = Identity matrix

 SEE ALSO:  mva_matrix_make.pro, fac_matrix_make.pro


 $LastChangedBy: pcruce $
 $LastChangedDate: 2009-03-30 14:17:08 -0700 (Mon, 30 Mar 2009) $
 $LastChangedRevision: 5454 $
 $URL: svn+ssh://thmsvn@ambrosia.ssl.berkeley.edu/repos/ssl_general/tags/tdas_5_1/cotrans/special/tvector_rotate.pro $

(See ssl_general/cotrans/special/tvector_rotate.pro)