section t of routines in global.i

all functions - t

tan


    tan  


Builtin function, documented at i0/std.i   line 565

SEE sin

tanh


    tanh  


Builtin function, documented at i0/std.i   line 604

SEE sinh

timer


    timer, elapsed  
 or timer, elapsed, split  


updates the ELAPSED and optionally SPLIT timing arrays.  These  
arrays must each be of type array(double,3); the layout is  
[cpu, system, wall], with all three times measured in seconds.  
ELAPSED is updated to the total times elapsed since this copy  
of Yorick started.  SPLIT is incremented by the difference between  
the new values of ELAPSED and the values of ELAPSED on entry.  
This feature allows for primitive code profiling by keeping  
separate accounting of time usage in several categories, e.g.--  
   elapsed= total= cat1= cat2= cat3= array(double, 3);  
   timer, elapsed0;  
   elasped= elapsed0;  
   ... category 1 code ...  
   timer, elapsed, cat1;  
   ... category 2 code ...  
   timer, elapsed, cat2;  
   ... category 3 code ...  
   timer, elapsed, cat3;  
   ... more category 2 code ...  
   timer, elapsed, cat2;  
   timer, elapsed0, total;  
The wall time is not absolutely reliable, owning to possible  
rollover at midnight.  
Builtin function, documented at i0/std.i   line 3555

SEE ALSO: track_reduce, bi_dir

track_integ


    result= track_integ(nlist, transp, selfem, last)  


integrates a transport equation by doing the sums:  
   transparency(i) = transparency(i-1) * TRANSP(i)  
   emissivity(i) = emissivity(i-1) * TRANSP(i) + SELFEM(i)  
returning only the final values transparency(n) and emissivity(n).  
The NLIST is a list of n values, so that many transport integrals  
can be performed simultaneously; sum(NLIST) = numberof(TRANSP) =  
numberof(SELFEM).  The result is 2-by-dimsof(NLIST).  
If TRANSP is nil, result is dimsof(NLIST) sums of SELFEM.  
If SELFEM is nil, result is dimsof(NLIST) products of TRANSP.  
TRANSP and SELFEM may by 2D to do multigroup integrations  
simultaneously.  By default, the group dimension is first, but  
if LAST is non-nil and non-zero, the group dimension is second.  
In either case, the result will be ngroup-by-2-by-dimsof(NLIST).  
track_solve is the higher-level interface.  
Interpreted function, defined at i0/hex.i   line 397

SEE ALSO: track_reduce, track_solve, track_solve

track_rays


    ray_paths= track_rays(rays, mesh, slimits)  


returns array of Ray_Path structs representing the progress of  
RAYS through the MESH between the given SLIMITS.  
Interpreted function, defined at i0/drat.i   line 1244

SEE ALSO: Ray_Path, integ_flat, get_ray-path

track_reduce


    nlist= track_reduce(c, s)  
 or nlist= track_reduce(c, s, rays, slimits)  


compresses the C and S returns from the tracking routines (see  
hex5_track) to the following form:  
  [cell1,cell2,cell3,..., cell1,cell2,cell3,..., ...]  
  [s1-s0,s2-s1,s3-s2,..., s1-s0,s2-s1,s3-s2,..., ...]  
returning nlist as  
  [#hits, #hits, ...]  
In this form, any negative #hits are combined with the preceding  
positive values, and #hits=1 (indicating a miss) appear as #hits=0  
in nlist.  Hence, nlist always has exactly Nrays elements.  
If RAYS is supplied, it is used to force the dimensions of the  
returned nlist to match the dimensions of RAYS (the value of RAYS  
is never used).  The RAYS argument need not have the trailing 2  
dimension, so if you specified RAYS as [P,Q] if the call to  
hex5_track, you can use just P or Q as the RAYS argument to  
track_reduce.  
If SLIMITS is supplied, it should be [smin,smax] or [smin,smax]-  
by-dimsof(nlist) in order to reject input S values outside the  
specified limits.  The C list will be culled appropriately, and  
the first and last returned ds values adjusted.  
With a non-zero flip= keyword, the order of the elements of  
C and S within each group of #hits is reversed, so that a  
subsequent track_solve will track the ray backwards.  If you  
use this, both the ray direction input to the tracking routine  
and any SLIMITS argument here should refer to the reverse of  
the ray you intend to track.  
Interpreted function, defined at i0/hex.i   line 158

SEE ALSO: hex5_track, c_adjust, track_solve, track_integ, bi_dir,
track_combine

track_solve


    result= track_solve(nlist, c, s, akap, ekap, last)  


integrates a transport equation for NLIST, C, and S returned  
by track_reduce (and optionally c_adjust).  The RAYS argument  
is used only to set the dimensions of the result.  AKAP and  
EKAP are mesh-sized arrays of opacity and emissivity, respectively.  
They may have an additional group dimension, as well.  The  
units of AKAP are 1/length (where length is the unit of S),  
while EKAP is (spectral) power per unit area (length^2), where  
the power is what ever units you want the result in.  The  
emission per unit volume of material is EKAP*AKAP; an optically  
thick block of material emits EKAP per unit surface.  
The NLIST is a list of n values, so that many transport integrals  
can be performed simultaneously; sum(NLIST) = numberof(AKAP) =  
numberof(EKAP).  The result is 2-by-dimsof(NLIST), where the  
first element of the first index is the transmission fraction  
through the entire ray path, and the second element of the  
result is the self-emission along the ray, which has the same  
units as EKAP.  
If EKAP is nil, result is dimsof(NLIST) -- exactly the same as  
the transparency (1st element of result) when both EKAP and AKAP  
are specified.  
If AKAP is nil, result is dimsof(NLIST).  In this case, EKAP  
must have units of emission per unit volume instead of per unit  
area; the result will be the sum of EKAP*S along each ray.  
AKAP and EKAP may by 2D to do multigroup integrations  
simultaneously.  By default, the group dimension is first, but  
if LAST is non-nil and non-zero, the group dimension is last.  
In either case, the result will be ngroup-by-2-by-dimsof(NLIST).  
To use in conjuction with hex5_track, one might do this:  
   c= hex5_track(mesh, rays, s);  
   nlist= track_reduce(c, s, rays);  
   c_adjust, c, mesh;  // if necessary  
   result= track_solve(nlist, c, s, akap, ekap);  
Interpreted function, defined at i0/hex.i   line 456

SEE ALSO: track_reduce, hex5_track

transpose


    transpose(x)  
 or transpose(x, permutation1, permutation2, ...)  


transpose the first and last dimensions of array X.  In the second  
form, each PERMUTATION specifies a simple permutation of the  
dimensions of X.  These permutations are compounded left to right  
to determine the final permutation to be applied to the dimensions  
of X.  Each PERMUTATION is either an integer or a 1D array of  
integers.  A 1D array specifies a cyclic permutation of the  
dimensions as follows: [3, 5, 2] moves the 3rd dimension to the  
5th dimension, the 5th dimension to the 2nd dimension, and the 2nd  
dimension to the 3rd dimension.  Non-positive numbers count from the  
end of the dimension list of X, so that 0 is the final dimension,  
-1 in the next to last, etc.  A scalar PERMUTATION is a shorthand  
for a cyclic permutation of all of the dimensions of X.  The value  
of the scalar is the dimension to which the 1st dimension will move.  
Examples:  Let x have dimsof(x) equal [6, 1,2,3,4,5,6] in order  
   to be able to easily identify a dimension by its length. Then:  
   dimsof(x)                          == [6, 1,2,3,4,5,6]  
   dimsof(transpose(x))               == [6, 6,2,3,4,5,1]  
   dimsof(transpose(x,[1,2]))         == [6, 2,1,3,4,5,6]  
   dimsof(transpose(x,[1,0]))         == [6, 6,2,3,4,5,1]  
   dimsof(transpose(x,2))             == [6, 6,1,2,3,4,5]  
   dimsof(transpose(x,0))             == [6, 2,3,4,5,6,1]  
   dimsof(transpose(x,3))             == [6, 5,6,1,2,3,4]  
   dimsof(transpose(x,[4,6,3],[2,5])) == [6, 1,5,6,3,2,4]  
Builtin function, documented at i0/std.i   line 1274

trapezoid


    trapezoid  


  
     Interpreted function, defined at i/romberg.i   line 95

tspline


    d2ydx2= tspline(tension, y, x)  


  -or-     yp= tspline(tension, d2ydx2, y, x, xp)  
  -or-     yp= tspline(tension, y, x, xp)  
computes a tensioned spline curve passing through the points (X, Y).  
The first argument, TENSION, is a positive number which determines  
the "tension" in the spline.  In a cubic spline, the second derivative  
of the spline function varies linearly between the points X.  In the  
tensioned spline, the curvature is concentrated near the points X,  
falling off at a rate proportional to the tension.  Between the points  
of X, the function varies as:  
      y= C1*exp(k*x) + C2*exp(-k*x) + C3*x + C4  
The parameter k is proportional to the TENSION; for k->0, the function  
reduces to the cubic spline (a piecewise cubic function), while for  
k->infinity, the function reduces to the piecewise linear function  
connecting the points.  The TENSION argument may either be a scalar  
value, in which case, k will be TENSION*(numberof(X)-1)/(max(X)-min(X))  
in every interval of X, or TENSION may be an array of length one less  
than the length of X, in which case the parameter k will be  
abs(TENSION/X(dif)), possibly varying from one interval to the next.  
You can use a variable tension to flatten "bumps" in one interval  
without affecting nearby intervals.  Internally, tspline forces  
k*X(dif) to lie between 0.01 and 100.0 in every interval, independent  
of the value of TENSION.  Typically, the most dramatic variation  
occurs between TENSION of 1.0 and 10.0.  
With three arguments, Y and X, spline returns the derivatives D2YDX2 at  
the points, an array of the same length as X and Y.  The D2YDX2 values  
are chosen so that the tensioned spline function returned by the five  
argument call will have a continuous first derivative.  
The X array must be strictly monotonic; it may either increase or  
decrease.  
The values Y and the derivatives D2YDX2 uniquely determine a tensioned  
spline function, whose value is returned in the five argument form.  
In this form, tspline is analogous to the piecewise linear interpolator  
interp; usually you will regard it as a continuous function of its  
fifth (or fourth) argument, XP.  
The XP array may have any dimensionality; the result YP will have  
the same dimensions as XP.  
The D2YDX2 argument will normally have been computed by a previous call  
to the three argument tspline function.  If you will be computing the  
values of the spline function for many sets of XP, use this five  
argument form.  
If you only want the tspline evaluated at a single set of XP, use the  
four argument form.  This is equivalent to:  
     yp= tspline(tension, tspline(tension,y,x), y, x, xp)  
The keywords DYDX1 and DYDX0 can be used to set the values of the  
returned DYDX(1) and DYDX(0) -- the first and last values of the  
slope, respectively.  If either is not specified or nil, the slope at  
that end will be chosen so that the second derivative is zero there.  
The function tspline (tensioned spline) gives an interpolation  
function which lies between spline and interp, at the cost of  
requiring you to specify another parameter (the tension).  
Interpreted function, defined at i/spline.i   line 122