PDS_VERSION_ID       = PDS3                                                   
RECORD_TYPE          = FIXED_LENGTH                                           
RECORD_BYTES         = 80                                                     
OBJECT               = TEXT                                                   
  INTERCHANGE_FORMAT   = ASCII                                                
  PUBLICATION_DATE     = 1999-08-24                                           
  NOTE                 = "Description of contents of SOFTWARE directory."     
END_OBJECT           = TEXT                                                   
END                                                                           
                                                                              
  Following files are included in the SOFTWARE directory.                     
                                                                              
  NB: Following common Unix practice, all file names should be converted      
to lower case before use, except that Makefile should have a leading upper    
case "M".                                                                     
                                                                              
  NB: Files in this directory, except for this file, do not have PDS labels.  
                                                                              
                                                                              
SOFTINFO.TXT                                                                  
                                                                              
  Description of contents of the SOFTWARE directory (this file).              
                                                                              
                                                                              
MAIN PROGRAMS                                                                 
=============                                                                 
                                                                              
RDHDR.F                                                                       
-------                                                                       
                                                                              
  FORTRAN 77 source code for program that reads and displays contents of      
individual RSC-11-6 header records.  Useful if familiarizing yourself with    
parameters stored in header and their typical values.  Requires subroutines   
get_hdr  and  prt_hdr0.  Usage                                                
                                                                              
                         rdhdr pathname [n]                                   
where                                                                         
            pathname    is path to RSC-11-6 data file                         
            n           is optional record number to display [default 1]      
                                                                              
                                                                              
UNPK.F                                                                        
------                                                                        
                                                                              
  FORTRAN 77 source code for program that separates header data from samples. 
Header information is sent to file  unpk.hdr  and data samples are sent to    
file  unpk.dat.  Requires subroutines  get_hdr  and  prt_hdr1.  Usage         
                                                                              
                         unpk pathname                                        
where                                                                         
            pathname    is path to RSC-11-6 data file                         
                                                                              
                                                                              
CRS2ASC.F                                                                     
---------                                                                     
                                                                              
  FORTRAN 77 source code for program that reads Univac binary CRS (Celestial  
Reference Set) file and converts it to ASCII.  CRS files contained position   
and velocity vectors as a function of time for Voyager encounters.  Binary    
was the nominal interchange format through the Uranus encounter, and ASCII    
was used for Neptune.  CRS2ASC was used to convert the  Titan, Saturn, and    
Uranus binary files to the Neptune format.  Requires routines  doy_mmdd,      
get_bits,  uni2ascii,  uni2ieee_dp,  and  uni2ieee_int.  This program is      
included in the archive for historical interest; there are no binary CRS      
files in the archive.                                                         
                                                                              
                                                                              
CRS2LBL.F                                                                     
---------                                                                     
                                                                              
  FORTRAN 77 source code for program that reads ASCII CRS file and extracts   
parameters useful in making PDS label.  Output goes to file  crs2lbl.dat.     
Calls subroutine  doy_mmdd.                                                   
                                                                              
                                                                              
PREP_11_6.F                                                                   
-----------                                                                   
                                                                              
  FORTRAN 77 source code for program that reformats Voyager Saturn VJnnnn     
series data for use in quick-look and other processing.  Major functions      
are:    converts 8-bit samples in 5056-byte records to                        
                16-bit samples in 1024-byte records (standard PREP format)    
        corrects for missing/gained samples (optional)                        
 	generates PREP-style header for output file                                 
                           Usage:                                             
           prep_11_6 labelfile tref [-s]                                      
  where                                                                       
                labelfile is the name of the PDS label file (must be in       
                              directory where program is run)                 
                tref      is reference time for positioning samples           
                              (often taken to be 0. if no midnight crossing)  
                -s        option to correct for missing/gained samples        
                              (default is no correction).  Note that the      
                              correction algorithm only handles small losses  
                              or gains; if the sample counter reports more    
                              than 300000 samples lost, for example, the      
                              correction fails (and so does the program).     
                              In these cases it is appropriate for the user   
                              to investigate; it may be that the sample       
                              count is erroneous and that the "no correction" 
                              mode is the better choice.                      
                                                                              
                                                                              
SUBROUTINES                                                                   
===========                                                                   
                                                                              
DOY_MMDD.F                                                                    
----------                                                                    
                                                                              
  FORTRAN 77 source code for subroutine that converts year/month/day to and   
year/day-of-year.                                                             
                                                                              
                                                                              
DTCVT.F                                                                       
-------                                                                       
                                                                              
  FORTRAN 77 source code for subroutine that normalizes  date-time  yyyy, dd, 
hh, mm, ss  if any value is out of range (too large).  Converts to            
YYYY-MM-DDThh:mm:ss  in 19-character string.  Valid for non-leap-years.       
                                                                              
                                                                              
GET_BITS.F                                                                    
----------                                                                    
                                                                              
  FORTRAN 77 source code for function that extracts up to 32 sequential bits  
from an integer array.  Used to extract bits when the bit stream crosses      
word boundaries.  Calls the FORTRAN 77 library routine  mvbits.               
                                                                              
                                                                              
GET_HDR.F                                                                     
---------                                                                     
                                                                              
  FORTRAN 77 source code for subroutine that unpacks RSC-11-6 header.         
Header content is returned as 42-element integer array.                       
                                                                              
                                                                              
PRT_HDR0.F                                                                    
----------                                                                    
                                                                              
  FORTRAN 77 source code for subroutine that gives detailed listing of        
RSC-11-6 record header.  Header content is listed at one line per parameter.  
Useful when a small number of headers are being examined, as in program       
RDHDR.                                                                        
                                                                              
                                                                              
PRT_HDR1.F                                                                    
----------                                                                    
                                                                              
  FORTRAN 77 source code for subroutine that gives compressed listing of      
RSC-11-6 record header.  Useful when listing a large number of headers, as    
in program UPNK.                                                              
                                                                              
                                                                              
SLIP.F                                                                        
------                                                                        
                                                                              
  FORTRAN 77 source code for function that returns the number of slipped      
samples for RSC-11-6 data.  See note regarding use of "-s" option on          
PREP_11_6.F above.                                                            
                                                                              
                                                                              
UNI2ASC.F                                                                     
---------                                                                     
                                                                              
  FORTRAN 77 source code for character function that converts one 6-bit       
Univac character to the equivalent 8-bit ASCII character.  Calls function     
get_bits.                                                                     
                                                                              
                                                                              
UNI2DP.F                                                                      
--------                                                                      
                                                                              
  FORTRAN 77 source code for double precision function that converts one      
72-bit Univac floating point number to the equivalent 64-bit IEEE floating    
point number.  Calls function  get_bits.                                      
                                                                              
                                                                              
UNI2INT.F                                                                     
---------                                                                     
                                                                              
  FORTRAN 77 source code for integer function that converts one 36-bit        
Univac integer to the equivalent 32-bit IEEE integer.  Calls function         
get_bits.                                                                     
                                                                              
                                                                              
XFR_11_6.F                                                                    
----------                                                                    
                                                                              
  FORTRAN 77 source code for subroutine that moves 8-bit unsigned samples     
from array a  to array b,  where they are stored as 16-bit samples.           
                                                                              
                                                                              
OTHER FILES                                                                   
===========                                                                   
                                                                              
MAKEFILE.CMD                                                                  
                                                                              
  File containing instructions for compiling and linking programs and         
subroutines under Solaris 2.5.1.  This file name should be converted to       
"Makefile" before use.