section h of routines in global.i

yorick banner

Home

Manual

Packages

Global Index

Keywords

Quick Reference

all functions - h

 
 
 
hardbc


 hardbc  
 
  

interpreted function, defined at i/demo1.i   line 98  
 
 
 
has_records


             has_records(file)  
 
     returns 1 if FILE has history records, 0 if it does not.  

interpreted function, defined at i0/std.i   line 2392  
 
 
 
hcp


             hcp  
             hcpon  
 
	    hcpoff  
     The hcp command sends the picture displayed in the current graphics  
     window to the hardcopy file.  (The name of the default hardcopy file  
     can be specified using hcp_file; each individual graphics window may  
     have its own hardcopy file as specified by the window command.)  
     The hcpon command causes every fma (frame advance) command to do  
     and implicit hcp, so that every frame is sent to the hardcopy file.  
     The hcpoff command reverts to the default "demand only" mode.  

builtin function, documented at i0/graph.i   line 205  
SEE ALSO: window,   fma,   plg,   eps,   hcps  
 
 
 
hcp_file


             hcp_file, filename, dump=0/1, ps=0/1  
 
     sets the default hardcopy file to FILENAME.  If FILENAME ends with  
     ".ps", the file will be a PostScript file, otherwise it will be a  
     binary CGM file.  By default, the hardcopy file name will be  
     "Aa00.cgm", or "Ab00.cgm" if that exists, or "Ac00.cgm" if both  
     exist, and so on.  The default hardcopy file gets hardcopy from all  
     graphics windows which do not have their own specific hardcopy file  
     (see the window command).  If the dump keyword is present and non-zero,  
     the current palette will be dumped at the beginning of each frame  
     of the default hardcopy file (default behavior).  With dump=0,  
     all colors are converted to a gray scale, and the output files are  
     smaller because no palette information is included.  
     Use ps=1 to make "Aa00.ps", "Ab00.ps", etc by default instead of CGM.  
     The dump= and ps= settings persist until explicitly changed by a  
     second call to hcp_file; the dump=1 setting becomes the default for  
     the window command as well.  

builtin function, documented at i0/graph.i   line 111  
SEE ALSO: window,   fma,   hcp,   plg  
 
 
 
hcp_finish


             filename= hcp_finish()  
          or filename= hcp_finish(n)  
 
     closes the current hardcopy file and returns the filename.  
     If N is specified, closes the hcp file associated with window N  
     and returns its name; use hcp_finish(-1) to close the default  
     hardcopy file.  

builtin function, documented at i0/graph.i   line 131  
SEE ALSO: window,   fma,   hcp,   hcp_out,   plg  
 
 
 
hcp_out


             hcp_out  
          or hcp_out, n  
 
     finishes the current hardcopy file and sends it to the printer.  
     If N is specified, prints the hcp file associated with window N;  
     use hcp_out,-1 to print the default hardcopy file.  
     Unless the KEEP keyword is supplied and non-zero, the file will  
     be deleted after it is processed by gist and sent to lpr.  

interpreted function, defined at i0/graph.i   line 141  
SEE ALSO: window,   fma,   hcp,   hcp_finish,   plg  
 
 
 
hcpoff


 hcpoff  
 
builtin function, documented at i0/graph.i   line 205  
SEE hcp  
 
 
 
hcpon


 hcpon  
 
builtin function, documented at i0/graph.i   line 205  
SEE hcp  
 
 
 
hcps


             hcps, name  
 
     writes the picture in the current graphics window to the  
     PostScript file NAME+".ps" (i.e.- the suffix .ps is added to NAME).  
     Legends are not written, but the palette is always dumped.  

interpreted function, defined at i0/graph.i   line 162  
SEE ALSO: hcps,   window,   fma,   hcp,   hcp_finish,   plg  
 
 
 
help


             help, topic  
          or help  
 
     Prints DOCUMENT comment from include file in which the variable  
     TOPIC was defined, followed by the line number and filename.  
     By opening the file with a text editor, you may be able to find  
     out more, especially if no DOCUMENT comment was found.  
     Examples:  
       help, set_path  
     prints the documentation for the set_path function.  
       help  
     prints the DOCUMENT comment you are reading.  
     This copy of Yorick was launched from the directory:  
     **** Y_LAUNCH (computed at runtime) ****  
     Yorick's "site directory" at this site is:  
     **** Y_SITE (computed at runtime) ****  
     You can find out a great deal more about Yorick by browsing  
     through these directories.  Begin with the site directory,  
     and pay careful attention to the subdirectories doc/ (which  
     contains documentation relating to Yorick), and i/ and  
     contrib/ (which contain many examples of Yorick programs).  
     Look for files called README (or something similar) in any  
     of these directories -- they are intended to assist browsers.  
     The site directory itself contains std.i and graph.i, which  
     are worth reading.  
     Type:  
       help, dbexit  
     for help on debug mode.  If your prompt is "dbug>" instead of  
     ">", dbexit will return you to normal mode.  
     Type:  
       quit  
     to quit Yorick.  

builtin function, documented at i0/std.i   line 33  
SEE ALSO: quit,   info,   print,   copyright,   warranty,  
legal  
 
 
 
help_worker


 help_worker  
 
  

interpreted function, defined at i0/std.i   line 99  
 
 
 
hex24b_track


 hex24b_track  
 
builtin function, documented at i0/hex.i   line 38  
SEE hex5_track  
 
 
 
hex24f_track


 hex24f_track  
 
builtin function, documented at i0/hex.i   line 38  
SEE hex5_track  
 
 
 
hex5_track


             c= hex5_track(mesh, rays, s)  
             c= hex24f_track(mesh, rays, s)  
             c= hex24b_track(mesh, rays, s)  
 
     track 3 x Nrays x 2 RAYS through the 3D MESH.  RAYS(,,1) are  
     points on the rays, while RAYS(,,2) are normalized ray directions.  
     The c return value and the S parameter are a long and double  
     array respectively, with number of elements equal to the total  
     number of intersections of all the RAYS with faces of the MESH,  
     plus one for any RAY which misses MESH entirely.  The values of  
     c are:  
       [#hits,cell1,cell2,cell3,..., #hits,cell1,cell2,cell3,..., ...]  
     where each #hits is followed by the list of cell indices (assuming  
     i=1, j=1, and k=1 are present but meaningless in cell arrays --  
     that is, assuming zone centered arrays have the same dimensions  
     as XYZ rather than one less in each direction).  Rays which miss  
     the mesh entirely have #hits=1, all others have #hits>=2 since they  
     must exit.  #hits<0 means a ray reentered the mesh for abs(#hits)  
     more face crossings, but this currently cannot happen.  The values  
     of S correspond to c:  
       [s0,s1,s2,s3,..., s0,s1,s2,s3,..., ...]  
     which are the distances along the ray measured from RAYS(,,1) in  
     the direction of RAYS(,,2) where the ray pierces a cell face.  For  
     rays which miss the mesh, the value of s0 is a diagnostic telling  
     why they missed (see compiled code).  
     Function hex5_track uses the 5-tet decomposition for hexes,  
     which is not unique when the quad faces are non-planar.  You may  
     be able to get an idea of this effect by setting hex_triang the  
     opposite way and redoing the trace.  
     Functions hex24f_track and hex24b_track use the face and body  
     centered 24-tet decompositions for hexes.  These are unique;  
     however, hex_triang may in rare cases change the trace slightly,  
     since the entry search algorithm still involves triangulating  
     the surface quads.  

builtin function, documented at i0/hex.i   line 38  
SEE ALSO: hydra_mesh,   hex_triang,   reg_track,  
track_reduce,   c_adjust,   pic3_rays,   conv3_rays  
 
 
 
hex_mesh


             mesh= hex_mesh(xyz, bound, nbnds, &mbnds, nblk, &blks, start)  
 
     create a 3D mesh object from the multiblock mesh parameters  
     XYZ   is NBLK 3 x Ni x Nj x Nk coordinate arrays packed together  
     BOUND is NBLK 3 x Ni x Nj x Nk face boundary markers packed  
     NBNDS is length of MBNDS  
     MBNDS is HX_blkbnd describing each internal block boundary face  
     NBLK  is number of blocks  
     BLKS  is NBLK HX_block objects describing the block structure  
     START is 0-origin 6*cell+face index of first boundary face/cell  
            or -1-cell to trace from centroid of that cell to point  
            p on ray to begin tracking  

builtin function, documented at i0/hex.i   line 10  
SEE ALSO: hex5_track,   hydra_mesh,   hex_startflag  
 
 
 
hex_mesh2


             mesh= hex_mesh2(xyz, bounds)  
 
     old interface for hex_mesh  
     create a 3D mesh object from the 3 x Ni x Nj x Nk coordinate  
     array XYZ and the list of 6 BOUNDS:  
       BOUNDS(1), BOUNDS(2)  for the i=1,Ni boundaries  
       BOUNDS(3), BOUNDS(4)  for the j=1,Nj boundaries  
       BOUNDS(5), BOUNDS(6)  for the k=1,Nk boundaries  
     The BOUNDS values are:  
       1   if this is a problem boundary  
       2   if this is a reflecting boundary  
       3   if this is a periodic boundary  

interpreted function, defined at i0/hex.i   line 596  
SEE ALSO: hydra_mesh  
 
 
 
hex_query


             start= hex_query(mesh, xyz, bound, mbnds, blks)  
 
     query a mesh created by hex_mesh, returning the arrays  
     passed to that function (these are not copies -- be careful  
     not to clobber them)  
     function return value is the start index  

builtin function, documented at i0/hex.i   line 27  
SEE ALSO: hex5_track,   hydra_mesh  
 
 
 
hex_startflag


             old_flag= hex_startflag(new_flag)  
 
     possibly set flag to NEW_FLAG, always return OLD_FLAG, where  
     flag value is 0 (default) to begin search for new entry point  
     at previous entry point, 1 to begin search for new entry point  
     from mesh start face for every ray.  Any other value of NEW_FLAG  
     returns OLD_FLAG without changing it.  

builtin function, documented at i0/hex.i   line 489  
SEE ALSO: hex_mesh  
 
 
 
hex_triang


             old_flag= hex_triang(new_flag)  
 
     possibly set flag to NEW_FLAG, always return OLD_FLAG, where  
     flag value is 0 for default mesh triangulation, 1 for opposite  
     triangulation, and 2 on input to signal not to change the  
     current value.  The triangulation value can affect the result  
     of hex5_track if the quad faces of the mesh are not planar.  

builtin function, documented at i0/hex.i   line 474  
SEE ALSO: hex5_track  
 
 
 
histeq_scale


             histeq_scale(z, top=top_value, cmin=cmin, cmax=cmax)  
 
     returns a byte-scaled version of the array Z having the property  
     that each byte occurs with equal frequency (Z is histogram  
     equalized).  The result bytes range from 0 to TOP_VALUE, which  
     defaults to one less than the size of the current palette (or  
     255 if no pli, plf, or palette command has yet been issued).  
     If non-nil CMIN and/or CMAX is supplied, values of Z beyond these  
     cutoffs are not included in the frequency counts.  

interpreted function, defined at i0/graph.i   line 1328  
SEE ALSO: bytscl,   plf,   pli  
 
 
 
histogram


             histogram(list)  
          or histogram(list, weight)  
 
     returns an array hist which counts the number of occurrences of each  
     element of the input index LIST, which must consist of positive  
     integers (1-origin index values into the result array):  
          histogram(list)(i) = number of occurrences of i in LIST  
     A second argument WEIGHT must have the same shape as LIST; the result  
     will be the sum of WEIGHT:  
          histogram(list)(i) = sum of all WEIGHT(j) where LIST(j)==i  
     The result of the single argument call will be of type long; the  
     result of the two argument call will be of type double (WEIGHT is  
     promoted to that type).  The input argument(s) may have any number  
     of dimensions; the result is always 1-D.  
   KEYWORD: top=max_list_value  
     By default, the length of the result is max(LIST).  You may  
     specify that the result have a larger length by means of the TOP  
     keyword.  (Elements beyond max(LIST) will be 0, of course.)  

builtin function, documented at i0/std.i   line 943  
SEE ALSO: digitize,   sort  
 
 
 
hydra_adj


 hydra_adj  
 
  

builtin function, documented at i0/hex.i   line 534  
 
 
 
hydra_array


             name_array = hydra_array(f, ublk, name)  

          or pname_arrays = hydra_array(f, ublk, [name1,name2,...,nameN])  
               eq_nocopy, name_array1, *pname_arrays(1)  
               ...  
               eq_nocopy, name_arrayN, *pname_arrays(N)  
 
     reads variable array NAME for user block UBLK from the hydra file F.    
     If NAME=="matlist", you get the "Materials_matlist" array.  
     Coordinates can be obtained using the names x, y or z.  
     Ublk numbering starts at 0.  
     Note that here zone centered arrays are given using the hydra convention  
     so that i=imax, j=jmax, k=kmax are missing.  Thus in order to use the   
     Yorick plc and plf functions correctly you should index the plotted  
     variable i.e. for a 2D array.  
     plf, den(1:-1,1:-1), y, x  

interpreted function, defined at i/hydra.i   line 868  
SEE ALSO: hydra_xyz,   hydra_mix  
 
 
 
hydra_blks


 hydra_blks  
 
  

builtin function, documented at i0/hex.i   line 515  
 
 
 
hydra_blocks


             gnblk= hydra_blocks(f, mdims, mlens)  
 
     returns number of blocks GNBLK, block dimensions MDIMS, and  
     block lengths MLENS for the hydra mesh in file F.  
     MDIMS is 3-by-NBLK, MLENS is GNBLK elements.  

interpreted function, defined at i/hydra.i   line 690  
SEE ALSO: hydra_xyz,   hydra_iparm  
 
 
 
hydra_bnd


 hydra_bnd  
 
  

builtin function, documented at i0/hex.i   line 520  
 
 
 
hydra_data


             name_array = hydra_data(f, name)  
          or pname_arrays = hydra_data(f, [name1,name2,...,nameN])  
               eq_nocopy, name_array1, *pname_arrays(1)  
               ...  
               eq_nocopy, name_arrayN, *pname_arrays(N)  
 
     reads variable NAME from the hydra file F.  If F is a multiblock  
     file, NAME_ARRAY will be 1-D; for single block problems it will  
     be 3-D.  If NAME=="matlist", you get the "Materials_matlist"  
     array.  Coordinates can be obtained using the names x, y or z.  
     In the second form, NAME1, ..., NAMEN are retrieved simultaneously,  
     which is useful when F is a large family of files.  
     Note that zone centered arrays are adjusted to the hex convention  
     that cells with i=1, j=1, k=1 are missing, rather than the hydra  
     convention that i=imax, j=jmax, k=kmax are missing.  

interpreted function, defined at i/hydra.i   line 348  
SEE ALSO: hydra_xyz,   hydra_mix,   hydra_array  
 
 
 
hydra_fparm


             value= hydra_fparm(f, name)  
          or names= hydra_fparm(f)  
 
     returns value of hydra parameter NAME from file F,  
     or a list of all names in NAME is not supplied.  
     If NAME is not a string, returns that parameter  
     or parameters (NAME is index in the returned list of names),  
     for example hydra_fparm(f,1:0) returns all parameters.  

interpreted function, defined at i/hydra.i   line 650  
SEE ALSO: hydra_xyz,   hydra_iparm  
 
 
 
hydra_gblk


             gblk= hydra_gblk(f)  
 
     return global block information from the hydra PDB/Silo file F.  
     Each hblk in the mesh corresponds to a particular imin:imax,  
     jmin:jmax, kmin:kmax in a particular gblk.  The return value is  
     a 2D long array 7-by-numberof(h blocks):  
     gblk(1,)=   user block number for this hblk  
     gblk(2:3,)= gblk [imin,imax] of this hblk  
     gblk(4:5,)= gblk [jmin,jmax] of this hblk  
     gblk(6:7,)= gblk [kmin,kmax] of this hblk  

interpreted function, defined at i/hydra.i   line 781  
SEE ALSO: hydra_xyz,   hydra_data,   openh  
 
 
 
hydra_iparm


             value= hydra_iparm(f, name)  
          or names= hydra_iparm(f)  
 
     returns value of hydra parameter NAME from file F,  
     or a list of all names in NAME is not supplied.  
     If NAME is not a string, returns that parameter  
     or parameters (NAME is index in the returned list of names),  
     for example hydra_iparm(f,1:0) returns all parameters.  

interpreted function, defined at i/hydra.i   line 610  
SEE ALSO: hydra_xyz,   hydra_fparm  
 
 
 
hydra_mesh


             mesh= hydra_mesh(f)  
          or mesh= hydra_mesh(f, ublk, i0, j0, k0, face)  
          or mesh= hydra_mesh(f, ublk, i0, j0, k0)  
 
     read a 3D mesh object from the hydra PDB/Silo file F.  
     Note that the boundary arrays are adjusted to the hex convention  
     that cells with i=1, j=1, k=1 are missing, rather than the hydra  
     convention that i=imax, j=jmax, k=kmax are missing.  
     In the first form, the ray entry search will start on the  
     first open boundary face in the mesh.  If the actual problem  
     boundary is not convex, you need to identify a surface of  
     constant i, j, or k in the problem which is convex, and which  
     all the rays you intend to trace intersect.  
     UBLK is the user block number (starting from 0),  
     I0, J0, K0 are the (1-origin) logical coordinates of a  
       hydra *cell*.  Note that unlike hex cells, the hydra  
       cell bounded by nodes (1,1,1) and (2,2,2) is numbered (1,1,1).  
       (Hex numbers it (2,2,2).)  
     FACE is the face number on cell (I0,J0,K0) which you want a  
       ray to enter.  0 means the -I face, 1 the +I face, 2 the -J  
       face, 3 the +J face, 4 the -K face, and 5 the +K face.  
       As you step from this cell to its neighbors, then to their  
       neighbors, and so on, this face must trace out a convex  
       surface for the ray entry search.  Rays not intersecting  
       this surface will not enter the problem; the ray trace  
       will begin at this surface, not at -infinity.  
     If FACE==-1 or is omitted (as in the third form), then the  
     given points on the rays are assumed to lie inside the mesh,  
     and a pseudo ray from the centroid of cell (I0, J0, K0) will be  
     tracked to the given point on each ray; the ray will be launched  
     into the cell containing that point.  

interpreted function, defined at i0/hex.i   line 542  
SEE ALSO: hex_query,   hex5_track,   hydra_data,   openh  
 
 
 
hydra_mix


             mixdat = hydra_mix(f, matlist)  
               eq_nocopy, mixn, *mixdat(1)  
               eq_nocopy, mixcell, *mixdat(2)  
               eq_nocopy, mixnmat, *mixdat(3)  
               eq_nocopy, mixhist, *mixdat(4)  
          or mix_array = hydra_mix(f, mixdat, name)  

          or pmix_array = hydra_mix(f, matlist, [name1,...,nameN], mixdat)  
               eq_nocopy, mix_array1, *pmix_array(1)  
               ...  
               eq_nocopy, mix_arrayN, *pmix_array(N)  
 
     In first form, returns MIXDAT and MATLIST for the hydra file F.  
     MIXDAT consists of two arrays: MIXN is a list of the number of  
     mixed cells for each block, and MIXCELL is an index array  
     into any hex global cell array (as returned by hydra_data),  
     MIXNMAT is the number of mix "zones" within each cell,  
     and MIXHIST is the list required in order to use the  
     histogram function on a mix array.  
     In the second form, reads the mix data for the variable NAME  
     in the hydra file F; the MIXDAT argument must have been returned  
     by a previous call to hydra_mix using the first form.  
     In the third form, MATLIST and MIXDAT are both returned along  
     with the set of variables NAME1, ..., NAMEN, so that a number of  
     variables can be retrieved in one call (useful when F is a large  
     family of files).  
     For example, to compute the temperature in each cell, using  
     a mass weighted average in mixed zones, you would do this:  
       den = hydra_data(f,"den");  
       tmat = hydra_data(f,"tmat");  
       mixdat = hydra_mix(f, matlist);  
       local mixcell, mixhist;  
       eq_nocopy, mixcell, *mixdat(2);  
       eq_nocopy, mixhist, *mixdat(4);  
       denx = hydra_mix(f, mixdat, "den");  
       tmatx = hydra_mix(f, mixdat, "tmat");  
       vf = hydra_mix(f, mixdat, "vf");  
       tavg = tmat;  
       tavg(mixcell) = histogram(mixhist, tmatx*denx*vf)/den(mixcell);  

interpreted function, defined at i/hydra.i   line 423  
SEE ALSO: hydra_xyz,   hydra_data  
 
 
 
hydra_mrk


 hydra_mrk  
 
  

builtin function, documented at i0/hex.i   line 528  
 
 
 
hydra_old


             hydra_old, 1  
             hydra_old, 0  
 
     use old (1) or new (0) hydra dump file variable names.  

interpreted function, defined at i/hydra.i   line 27  
SEE ALSO: hydra  
 
 
 
hydra_rootfile


 hydra_rootfile  
 
  

interpreted function, defined at i/hydra.i   line 825  
 
 
 
hydra_start


             hydra_start, mesh, start  
 
     change the starting cell of the hydra MESH (returned by hydra_mesh)  
     to START.  If called as a function, returns old start value.  

interpreted function, defined at i0/hex.i   line 688  
SEE ALSO: hydra_mesh,   hydra_data  
 
 
 
hydra_ublk


             ublk= hydra_ublk(f)  
 
     return user block information from the hydra PDB/Silo file F.  
     Each hblk in the mesh corresponds to a particular imin:imax,  
     jmin:jmax, kmin:kmax in a particular ublk.  The return value is  
     a 2D long array 7-by-numberof(h blocks):  
     ublk(1,)=   user block number for this hblk  
     ublk(2:3,)= ublk [imin,imax] of this hblk  
     ublk(4:5,)= ublk [jmin,jmax] of this hblk  
     ublk(6:7,)= ublk [kmin,kmax] of this hblk  

interpreted function, defined at i/hydra.i   line 741  
SEE ALSO: hydra_xyz,   hydra_data,   openh  
 
 
 
hydra_varname


 hydra_varname  
 
  

interpreted function, defined at i/hydra.i   line 409  
 
 
 
hydra_xyz


             mesh= hydra_xyz(f)  
          or mesh= hydra_xyz(f, ublk, i0, j0, k0, face)  
          or mesh= hydra_xyz(f, ublk, i0, j0, k0)  
 
     read a 3D mesh object from the hydra PDB/Silo file F.  
     The returned mesh is _lst(xyz, bound, mbnds, blks, start).  
     Note that the boundary arrays are adjusted to the hex convention  
     that cells with i=1, j=1, k=1 are missing, rather than the hydra  
     convention that i=imax, j=jmax, k=kmax are missing.  
     In the first form, the ray entry search will start on the  
     first open boundary face in the mesh.  If the actual problem  
     boundary is not convex, you need to identify a surface of  
     constant i, j, or k in the problem which is convex, and which  
     all the rays you intend to trace intersect.  
     UBLK is the user block number (starting from 0),  
     I0, J0, K0 are the (1-origin) logical coordinates of a  
       hydra *cell*.  Note that unlike hex cells, the hydra  
       cell bounded by nodes (1,1,1) and (2,2,2) is numbered (1,1,1).  
       (Hex numbers it (2,2,2).)  
     FACE is the face number on cell (I0,J0,K0) which you want a  
       ray to enter.  0 means the -I face, 1 the +I face, 2 the -J  
       face, 3 the +J face, 4 the -K face, and 5 the +K face.  
       As you step from this cell to its neighbors, then to their  
       neighbors, and so on, this face must trace out a convex  
       surface for the ray entry search.  Rays not intersecting  
       this surface will not enter the problem; the ray trace  
       will begin at this surface, not at -infinity.  
     If FACE==-1 or is omitted (as in the third form), then the  
     given points on the rays are assumed to lie inside the mesh,  
     and a pseudo ray from the centroid of cell (I0, J0, K0) will be  
     tracked to the given point on each ray; the ray will be launched  
     into the cell containing that point.  
     You can set a hydra_bnd_hook function before calling hydra_xyz  
     if the boundary conditions for hex need to be different than  
     for hydra.  

interpreted function, defined at i/hydra.i   line 104  
SEE ALSO: hydra_bnd_hook,   hydra_data,   openh  
 
 
 
hydrap_getblk


 hydrap_getblk  
 
  

interpreted function, defined at i/hydra.i   line 853  
 
 
 
hydrap_root


 hydrap_root  
 
  

interpreted function, defined at i/hydra.i   line 830