Data File Structure &
Data Storage and Retrieval Routines
Ravi Kochhar
Department of Physiology
University of Wisconsin
Madison, Wi. 53706
Technical Report no. 12
June 1993
Rev. 1.12, Feb. 28, 2002
|
DAFLIB Data File Structure & Data Storage and Retrieval Routines |
|
| Table of Contents |
Ravi Kochhar Department of Physiology University of Wisconsin Madison, Wi. 53706 Technical Report no. 12 June 1993 Rev. 1.12, Feb. 28, 2002 |
Back to Top
(1) Introduction
This document contains a description of the data file structure used
for storage of most (but not all) auditory physiology and behavior data
in the Auditory Physiology Labs at the University of Wisconsin - Madison.
The data file structure in use at present is an evolution
of the file structure first developed for the Harris computer in the mid
1970's, adapted for the PDP-11/RSX computer in the early 1980's, and
refined into it's present form for VAX/VMS computers in the mid-
1980's (see Refs. 1 to 6).
It is currently (April 2000) in the process of being updated for the
Microsoft Windows environment.
Examples of data collection programs that store data using this file
structure are RA,
FF,
COM,
BC,
TH, and others.(see Refs. 8 to 11).
The routines described in this report are available to access the
data files that conform to this file structure.
Back to Top
(2) Data File Structure
The following is a summary of the data file structure currently in
use for storage of auditory data on the Vaxstation and MicroVax
computers.
(Note: The file structure is currently being adapted for use on MS-Windows
and will undergo significant revisions).
A single data file is typically used for storage of all data for
one animal. This is not a requirement, and in some cases more than one
file may be used for a single animal. For convenience, it is recommended
that the name of this file include the animal number or ID in some way,
though this is not a requirement, and the file can have any name. The
phrase "Data File" is used freely in this report to refer to this file,
i.e. the file holding all the data for one animal.A new data file is
normally created by using the program "SETUP". A data file is sometimes
also referred to as the "Experimental Data File" (or EDF).
A data file is a binary, direct-access file. It has a record
length of 128 words, or 512 bytes. Each block of 128 words is also
referred to as a "block".
Data stored in the data file are grouped into individual "data
sets". A data set is simply data that is logically connected in some
way, and is referred to by a "data set ID" (or DSID). Examples of data
sets include (a) a Response Area (b) a Tuning Curve (c) an Acoustic
Calibration (d) a Noise Waveform etc.
A data file is thus simply a collection of data sets. The first
part of each data file consists of a "directory". This directory
contains a complete list of all the data set ID's in the file and their
locations within the data file. A data file can be pictured as a
directory followed by individual data sets.
The type of data stored within each data set can be almost
anything, and no restriction is imposed by the data file structure.
However, the structure of the directory is well defined, as is the
structure of a "mandatory header" with each data set. Moreover, the
internal structure of each data set must be described by a "schema". A
schema is a description of the data set written in Data Description
Language (DDL). A sample schema is
attached near the end of this report.
The following are general rules that apply to data files :
Back to Top
Directory Structure
The directory is the first item in any data file. It consists of
a 16-word "directory header" followed by a number of "directory entries"
which are 8 words each. (Note: one word = 32 bits).
The "Date Last Modified" should be updated each time a data set is
added or deleted from the file, or anytime the contents of a particular
data set are modified in any way.
Immediately following the directory header, i.e. from word 17
onwards of the first block of the data file, are the individual
direectory entries, one for each data set. The number of entries is
stored in word (4) of the directory header (see above). The format of
each directory entry is :
Each data set has a 13-word mandatory header, containing the
following information :
Note that much of the information in each directory entry is
duplicated in the data set headers. This means that even if a file were
damaged such that the directory were completely lost, it would still be
possible to scan the body of the file and re-create the directory.
(3) Usage
VAX/VMS: The routines described in this report are all
in library DAFLIB and may be linked to user programs as follows :
LINK program,........,L:DAFLIB/L
The library DAFLIB resides in directory L: on the VAX.
Windows 9x/NT/2000:
See "DAFLIB for Windows" section below
In all the routines described below, an error code value NER is
returned. The value of NER indicates whether the routine completed
successfully or whether an error condition was detected. In all cases, a
value of NER=0 indicates successful completion. If NER is non-zero, it
can indicate a variety of problems. A description of all possible values
of NER, and their interpretation, is attached at the end of this report.
Please note that, in most cases, the routine INITDF (or INITRF) or
the routine INITSC must be called before any of the other routines are
called. INITDF is used most often before calling any of the data storage
routines, such as WENTRY, DAFOUT etc., while INITSC should be called
before calling most of the data retrieval routines such as SPKT, VRANG
etc. Each of the routine descriptions includes a short note about which
routine needs to be called first.
INITDF and INITDFC are the only routines that open the data file
for write-access.
All integer arguments must be declared type INTEGER. On the VAX
this means 4-byte integers. In a few cases the integer arguments must be
explicitly declared as INTEGER*2 or as INTEGER*4. These cases are
mentioned with each routine where applicable.
The routines can be called from any VMS compatible language, e.g.
FORTRAN or C. From FORTRAN, they are all called as subroutines, e.g.
"CALL INITDF(..)".
Examples of use are provided in a separate section below.
Back to Top
(4) DAFLIB for Windows
DAFLIB for 32-bit MS-Windows (Win-95/98/NT/2000) is now available, and may be
downloaded from
http://www.neurophys.wisc.edu/ftp/pub/AUDSTUFF/WINDOWS/.
It is also available via anonymous ftp from ftp.physiology.wisc.edu in
folder pub/audstuff/windows.
It is available as the static library DAFLIB.LIB.
You should also get the library MISLIB.LIB from the same location, and also
place it in c:\audstuff.
The MISLIB.LIB library contains the routines WHATSYS and DFTYPE (see below),
which are necessary to compile programs transparently on VMS and Windows
systems.
The usage is similar to that for the VMS platform, and the routine
descriptions below apply equally to both platforms.
The file DAFLIB.LIB should be placed in a suitable folder on your hard
drive (we recommend a folder named c:\audstuff) and specified in the link
include options. For example, if you are using Microsoft Visual Studio, open
your project, then select Project -> Settings, and add c:\audstuff\daflib.lib
to the "Object/Library modules" field. (Note: you will also need to include
the library MISLIB.LIB in a similar way, see below).
In order to use programs that call DAFLIB routines transparently on both
VMS and Windows systems, it is necessary to inform DAFLIB about (a) what the
current system is and (b) what file type is being used.
This is necessary because the way the two systems store binary data is
different (e.g. floating point numbers are represented differently).
DAFLIB has been updated to work with either format on either system, but
the program must include a call to the routine FILSYS.
The new DAFLIB routine for this purpose is FILSYS (described below) and it
requires two inputs, the system type-code (IWSYST), and the file-type code
(IFTYP).
The values of IWSYST and IFTYP can be obtained simply by calling two new
routines, WHATSYS and DFTYPE, which are in the library MISLIB.
The brief instructions for the order in which the routines should be called
are as follows:
See below for a detailed description of the arguments of these routines.
(5) Description
(6) Examples of Use
The following are examples of C and FORTRAN programs used to fetch some
basic imformation from a data file and a data set. In these examples the
checking for error codes (NER) has been omitted for brevity. In a real
case, you should always check the value of NER after every call to a
DAFLIB routine.
<...The examples will be added in a future version...>
Back to Top
(7) Recovery of Harris Data
Data collected using the Harris computer may also be accessed
directly using routines in DAFLIB. It is assumed that Harris data files
of interest have been transferred to a disc on the VAX/VMS computer
or a Windows system.
To retrieve data from a Harris format file, a parallel set of
routines have been written. These routines also reside in DAFLIB, and
have names and functions which are the same as described above,
except that the letter "H" is added as a prefix to each name. For
example, the HINITSC is the same as routine INITSC except that it
works on Harris data files.
The following routines are available in DAFLIB for accessing
Harris data files :
Back to Top
(8) Sample Data Schema
(9) References
(10) Acknowledgements
The work described in this report has been carried out under the
overall supervision of Dr. W.S.Rhode.
The file structure described has been in use at the
Neurophysiology Auditory Labs since 1977. The first version (for the
Harris computer) was specified at a series of meetings in 1976 attended
by Bill Rhode, V. Soni, Mike Mansfield, Y. Samad, John Dickson, Bob
Wickesberg, and the author. Over the years it has been refined and
adapted to other computers, mainly the PDP-11/RSX (1982) and VAX/VMS
(1986).
Thanks are due to Yusuf Samad and Mike Clark for help with
programming many of the routines. Many users of the auditory lab have
contributed over the years with helpful ideas and bug discoveries.
The Data Description Language (DDL) used to describe individual
data sets is a simplified version of the DDL developed by the Data Base
Group at the Laboratory Computer Facility under the direction of Bill
Rhode.
Supported in part by a grant from NIH.
Back to Top
(11) Error Codes
If you have questions or suggestions about this document,
please send them by e-mail to
Return to Documentation Page
Directory Header
Word Number (32-bit) Contents
-------------------- --------
1-3 Animal ID (12 characters)
4 No. of current entries
5 Size of directory (in blocks)
6 Unused
7-8 Date last modified (DD-MMMYY)
9-16 Unused
Directory Entry
Word Number (32-bit) Contents
-------------------- --------
1-2 Schema name (8 characters)
3 Data set size (in blocks)
4-6 DSID (12 characters)
7 Location of data set (block)
8 Experiment Type Code (4 chars)
Data Set Header
Word Number (32-bit) Contents
-------------------- --------
1-2 Schema name (8 characters)
3 Data set size (blocks)
4-6 Animal ID (12 characters)
7-9 Data set ID (12 characters)
10-11 Date (DDMMM-YY) (8 characters)
12 Time in 10th of secs since midnight
13 Experiment type code (4 characters)
:
CALL WHATSYS(IWSYST)
CALL INITDF(NAMFIL,LUN,NER)
CALL DFTYPE(LUN,IFTYP,NER)
CALL FILSYS(IWSYST,IFTYP,NER)
:
other DAFLIB routines
:
INITDF(NAMFIL,LUN,NER)
Open the data file and assign it to logical unit number LUN.
NAMFIL : Data File Name (integer array, whose last byte must be 0)
LUN : Logical unit number to assign to file (1,2,3,...etc.)
NER : Error code (normally zero)
NAMFIL and LUN must be supplied by the calling program, while
NER will be returned. This routine should normally be called
once before any of the other routines are called. The exception
to this is that any one of the following routines may be called
instead (they all open the data file) :
INITRF, INITDFC, INITSC, INITRFC
Note that this routine opens the file Read and Write access. In
some cases it is necessary to open the file for Read-only access.
Use either INITRF or INITRFC for those cases.
INITDFC(NAMFIL,LUN,NER)
This routine is similar INITDF in every way except that here
"NAMFIL" is a character string data type (as compared to an
integer array in INITDF).
INITRF(NAMFIL,LUN,NER)
This routine is similar INITDF in every way except that here the
file is opened for Read-only access. This means that those DAFLIB
routines that write into the file (e.g. DAFOUT) cannot be called after
this one.
INITRFC(NAMFIL,LUN,NER)
This routine is similar INITDF in every way except that here the
file is opened for Read-only access, AND the file name is supplied as a
character string (not as an integer array). This means that those DAFLIB
routines that write into the file (e.g. DAFOUT) cannot be called after
this one.
MDSID(DSID,IBUF,LOC,KODE,NER)
Search (match) a data set in the directory. If found, return its
entry contents and location.
DSID : Data set ID (type character string)
IBUF : Directory entry (8 word Integer array)
LOC : Location in directory (word number)
KODE : if=0 then DSID not found, if=N then N is the sequence
number of DSID in the directory
NER : Error code, normally zero.
DSID must be supplied by the user, while IBUF, LOC, KODE and NER
will be returned. Note that the DSID can contain 12 or fewer characters.
INITDF (or INITRF) must be called before this routine.
MDSIDI(IDSID,IBUF,LOC,KODE,NER)
Search (match) a data set in the directory. If found, return its
entry contents and location.
This routine is identical to MDSID (see above) in every way except
that here IDSID is an integer array (of 12 characters).
GETESQ(NUM,IBUF,NER)
Get the contents of the NUM'th entry in the directory.
NUM : Sequence number in directory
IBUF : Directory entry (8 word Integer array)
NER : Error code, normally zero.
NUM must be supplied by the calling program, IBUF and NER are
returned by this routine.
INITDF (or INITRF etc.) must be called before this routine.
GETDH(NBUF,NER)
Get the directory header.
NBUF : Directory header (16 word Integer array)
NER : Error code, normally zero.
Both NBUF and NER are returned by this routine. For a description
of the directory header format, see the chapter titled "Data File
Structure" in this report.
INITDF (or INITRF etc.) must be called before this routine.
WRDH(NBUF,NER)
Write the directory header to the EDF.
NBUF : Directory header (16 word Integer array)
NER : Error code, normally zero.
NBUF must be supplied, while NER will be returned. For a description
of the directory header format, see the chapter titled "Data File
Structure" in this report.
INITDF (or INITRF etc.) must be called before this routine.
SPDIR(NENT,NLFT,NXTL,NER)
Check available space, and next available location in the
directory.
NENT : Number of entries currently in directory.
NLFT : Available space (in words)
NXTL : Next available location (word number)
NER : Error code, normally zero.
NENT, NLFT, NXTL and NER are all returned by this routine.
INITDF (or INITRF) must be called before this routine.
WENTRY(IBUF,NER)
Make a new entry in the directory.
IBUF : Directory entry (8 word integer array)
NER : Error code, normally zero.
IBUF must be supplied by the calling program, NER will be
returned. For a description of the directory entry format, see the
chapter titled "Data File Structure" in this report.
INITDF must be called before this routine.
WENTRYN(IBUF,NER)
Similar to WENTRY except here the routine does not check whether
the DSID already exists in the file or not. This is a special
purpose routine intended for special cases only where there is
no chance of DSID's being duplicated - e.g. when ID's are
auto-generated within a program, and where there are so many
data sets that there is a real benefit from skipping the check.
In general it is highly recommended that WENTRY be called instead,
since a directory with duplicate DSID's is invalid.
DENTRY(IBUF,NER)
Delete the entry with specified DSID from the directory. All
subsequent entries are moved up one space.
DSID : Data set ID (Integer array)
NER : Error code, normally zero.
DSID must be supplied, while NER will be returned by this routine.
INITDF must be called before this routine.
SPCDF(NSPAC,NXTA,NER)
Check available space in the data file.
NSPAC : Available space (in blocks)
NXTA : Next available location (block no.)
NER : Error code, normally zero.
NSPAC, NXTA and NER are all returned by this routine.
INITDF (or INITRF) must be called before this routine.
DENTSQ(NUM1,NUM2,NDEL,NER)
Delete the entries with sequence numbers NUM1 to NUM2 in the
directory. All subsequent entries are moved up so there are no gaps in
the directory.
NUM1 : Sequence number FROM
NUM2 : Sequence number TO
NDEL : Number of entries actually deleted
NER : Error code, normally zero.
NUM1 and NUM2 must be supplied, while NDEL and NER will be
returned by this routine. NUM1 must be less than or equal to NUM2.
INITDF must be called before this routine.
CHAID(ANID,NER)
Change the Animal ID in the directory header, and in the headers
of all data sets in the current data file.
ANID : Animal ID (3 word integer array)
NER : Error code, normally zero.
ANID must be supplied, NER will be returned. All traces of the
previous Animal ID are erased, and replaced by ANID.
INITDF must be called before this routine.
CHDID(IDOLD,IDNEW,NER)
Change the data set ID in the directory and the data set header in
current data file.
IDOLD : Current data set ID (3 word integer array)
IDNEW : New data set ID (3 word integer array)
NER : Error code, normally zero.
IDOLD and IDNEW must be supplied by the calling program, while NER
will be returned.
INITDF must be called before this routine.
DAFOUT(LOC,IVAL,NER)
Write a 32-bit integer value to specified location in data file.
LOC : Location in file (rel. to start of file) (or -1)
IVAL : Integer (32-bit) value to be written out
NER : Error code, normally zero
LOC and IVAL must be supplied, while NER will be returned.
LOC is expressed as a (32-bit) word location relative to the
start of the file. Thus LOC=1 means the first word in the file,
while LOC=257 means the first word of the third block.
This routine does buffered writes, which means that IVAL will
not be written to disk immediately. To be sure that your data
is written to disk, be sure to call DAFOUT one final time with
IVAL=-1. A value of -1 for IVAL forces an immediate write to disk
of the memory buffer. A call to CLOSDF will also flush the buffer
to disk.
INITDF or INITDFC must be called before calling this routine.
DAFOUR(LOC,RVAL,NER)
Write a single precision floating point value to specified
location in data file.
LOC : Location in file (rel. to start of file) (or -1)
RVAL : Single-precision floating point value to be written out
NER : Error code, normally zero
LOC and RVAL must be supplied, while NER will be returned.
If the routines WHATSYS and FILSYS have been correctly called
then this routine will automatically convert between IEEE and
VAX floating point formats as necessary.
See the notes for DAFOUT above for additional important information.
DAFOUC(LOC,CVAL,NC,NER)
Write a character string to specified location in data file.
LOC : Location in file (rel. to start of file) (or -1)
CVAL : Character String to be written out (type CHARACTER)
NC : Number of characters in CVAL
NER : Error code, normally zero
LOC, CVAL and NC must be supplied, while NER will be returned.
Note that CVAL is a Fortran Character String.
See the notes for DAFOUT above for additional important information.
DAFOIA(LOC,IBUF,NW,NER)
Write an integer array to specified location in data file.
LOC : Location in file (rel. to start of file) (or -1)
IBUF : Integer Array to be written out (32-bit)
NW : Number of words to write
NER : Error code, normally zero
LOC, IBUF and NW must be supplied, while NER will be returned.
Note that IBUF is a 32-bit integer array.
See the notes for DAFOUT above for additional important information.
DAFORA(LOC,RBUF,NW,NER)
Write a floating point array to specified location in data file.
LOC : Location in file (rel. to start of file) (or -1)
RBUF : Floating point Array to be written out
NW : Number of values to write
NER : Error code, normally zero
LOC, RBUF and NW must be supplied, while NER will be returned.
Note that RBUF is a single precision floating point array.
If the routines WHATSYS and FILSYS have been correctly called
then this routine will automatically convert between IEEE and
VAX floating point formats as necessary.
See the notes for DAFOUT above for additional important information.
DAFIN(LOC,IVAL,NER)
Read a 32-bit integer value from specified location in data file.
LOC : Location in file (rel. to start of file)
IVAL : Integer (32-bit) variable to hold value that is read
NER : Error code, normally zero
LOC must be supplied, while IVAL and NER will be returned.
LOC is expressed as a (32-bit) word location relative to the
start of the file. Thus LOC=1 means the first word in the file,
while LOC=257 means the first word of the third block.
INITDF (or INITDFC, INITRF etc.) must be called before calling
this routine.
DAFINR(LOC,RVAL,NER)
Read a floating point value from specified location
in data file.
LOC : Location in file (rel. to start of file)
RVAL : Real variable to hold value that is read
NER : Error code, normally zero
LOC must be supplied, while RVAL and NER will be returned.
Note that RVAL is a single precision floating point variable.
LOC is expressed as a (32-bit) word location relative to the
start of the file. Thus LOC=1 means the first word in the file,
while LOC=257 means the first word of the third block.
If the routines WHATSYS and FILSYS have been correctly called
then this routine will automatically convert between IEEE and
VAX floating point formats as necessary.
INITDF (or INITDFC, INITRF etc.) must be called before calling
this routine.
DAFINC(LOC,NC,CVAL,NER)
Read a character string from specified location in data file.
LOC : Location in file (rel. to start of file)
NC : Number of characters to read
CVAL : Character variable to hold value that is read
NER : Error code, normally zero
LOC and NC must be supplied, while CVAL and NER will be returned.
LOC is expressed as a (32-bit) word location relative to the
start of the file. Thus LOC=1 means the first word in the file,
while LOC=257 means the first word of the third block.
INITDF (or INITDFC, INITRF etc.) must be called before calling
this routine.
DAFIRA(LOC,RBUF,NW,NER)
Read an array of floating point values from specified location
in data file.
LOC : Location in file (rel. to start of file)
RBUF : Real variable to hold values that are read
NW : Number of values to read
NER : Error code, normally zero
LOC and NW must be supplied, while RBUF and NER will be returned.
Note that RBUF is a single precision floating point array.
LOC is expressed as a (32-bit) word location relative to the
start of the file. Thus LOC=1 means the first word in the file,
while LOC=257 means the first word of the third block.
If the routines WHATSYS and FILSYS have been correctly called
then this routine will automatically convert between IEEE and
VAX floating point formats as necessary.
INITDF (or INITDFC, INITRF etc.) must be called before calling
this routine.
INITSC(FNAM,LUN,DSID,NER)
Initialize file and prepare to retrieve data for specified data
set
FNAM : Data File Name (type character string)
LUN : Logical unit number (to which file will be assigned)
DSID : Data set ID (type character string)
NER : Error code, normally zero.
FNAM, LUN and DSID must be supplied, while NER will be returned.
You must call this routine once before calling most of the routines below
for retrieving data for a particular data set.
This routine opens the data file for "read access" only.
INITSCW(FNAM,LUN,DSID,NER)
Similar to INITSC in every way except that here we open for
"write access". It is recommended that this be used in special
cases only - use INITSC for normal data retrieval.
I4VL(NAME,I4VAL,NER)
Retrieve the value for any Integer*4 variable whose name is
supplied.
NAME : Name of variable (type character string) (8 chars)
I4VAL : Value returned (integer)
NER : Error code, normally zero.
NAME must be supplied, I4VAL and NER will be returned. NAME must
exist as a variable name in the schema for the current data set
(specified earlier to INITSC).
INITSC (or INITSCW) must be called before this routine.
RLVL(NAME,VAL,NER)
Retrieve the value for any Real (floating point) variable whose
name is supplied.
NAME : Name of variable (type character string) (8 chars)
VAL : Value returned (real)
NER : Error code, normally zero.
NAME must be supplied, VAL and NER will be returned.
NAME must exist as a variable name in the schema for the current
data set (specified earlier to INITSC).
INITSC (or INITSCW) must be called before this routine.
I4AVL(NAME,MAX,I4A,NV,NER)
Retrieve the values for an Integer*4 vector whose name is
supplied.
NAME : Name of variable (2 word integer array)
MAX : Max. number of values that "I4A" can hold (size of I4A)
I4A : Integer*4 array in which values returned
NV : Number of values actually returned
NER : Error code, normally zero.
NAME and MAX must be supplied, I4A, NV and NER will be returned.
NAME must exist as a variable name in the schema for the current data set
(specified earlier to INITSC).
INITSC must be called before this routine.
RLAVL(NAME,MAX,RLA,NV,NER)
Retrieve the values for a Real vector whose name is supplied.
NAME : Name of variable (2 word integer array)
MAX : Max. number of values that "RLA" can hold (size of RLA)
RLA : Real array in which values returned
NV : Number of values actually returned
NER : Error code, normally zero.
NAME and MAX must be supplied, RLA, NV and NER will be returned.
NAME must exist as a variable name in the schema for the current data set
(specified earlier to INITSC).
INITSC must be called before this routine.
CHVL(NAME,MAX,ICH,NV,NER)
Retrieve the values for a character string whose name is supplied.
NAME : Name of variable (type character string) (8 chars)
MAX : Max. number of chars. that "ICH" can hold (size of ICH)
ICH : Character string in which values returned
NV : Number of characters actually returned
NER : Error code, normally zero.
NAME and MAX must be supplied, ICH, NV and NER will be returned.
NAME must exist as a variable name in the schema for the current
data set (specified earlier to INITSC).
INITSC (or INITSCW) must be called before this routine.
VSEQ(NSEQ,MAX,VAL,NV,NER)
Retrieve the variable values corresponding to a particular
sequence number in current data set.
NSEQ : Sequence number for which values to be retrieved
MAX : Max. number of values that "VAL" can hold (size of VAL)
VAL : Real array to contain values
NV : Number of values actually returned (in VAL)
NER : Error code, normally zero.
NSEQ and MAX must be supplied, VAL, NV and NER will be returned.
INITSC must be called before this routine.
SEQV(VAL,NV,INDX,NSEQ,NTHER,NER)
Retrieve the INDX'th sequence number corresponding to a particular
set of variable values (e.g. FREQ and SPL).
VAL : Real array containing values
NV : Number of values actually returned (in VAL)
INDX : Occurrence number of specified values (usually 1)
NSEQ : Sequence number
NTHER : Total number of stimulus points with these values
NER : Error code, normally zero.
VAL, NV and INDX must be supplied, while NSEQ, NTHER and NER will
be returned by this routine.
Note: It is possible to have more than one sequence with the same
variable values in a particular data set.
INITSC must be called before this routine.
SPKT(NSEQ,NTRN,INDX,MAX,BUF,NS,NSR,NSSQ,NER)
Retrieve upto MAX spike times for specified stimulus point and
repetition number.
NSEQ : Sequence number for which spike times to retrieved
NTRN : Trial number for which spikes to be retrieved
INDX : Buffer index number (1,2,3... etc.)
MAX : Size of array BUF
BUF : Real array to contain spike times
NS : Actual number of spike times returned
NSR : Total number of spikes in this trial
NSSQ : Total number of spikes at this stimulus point
NER : Error code, normally zero.
NSEQ, NTRN, INDX and MAX must be supplied by the calling program,
while BUF, NS, NSR, NSSQ and NER will be returned.
The spike times are returned in units of milliseconds.
The value of INDX determines which block of MAX spikes to
retrieve. If INDX=1 then first MAX spikes, if it is 2 then second MAX
spikes etc. NS is the actual number of spikes returned. The actual number
of spikes returned (in BUF) is always between 0 and MAX.
INITSC must be called before this routine.
SPKTM(IUC,NSEQ,NTRN,INDX,MAX,BUF,NS,NSR,NSSQ,NER)
Retrieve upto MAX spike times for current data set.
This is very similar to routine SPKT above, with the addition of
the parameter "IUC". IUC is a 64-word integer array containing the UET
channel numbers for which data is to be retrieved and ending with a
negative number.
For example, if IUC(1)=0, IUC(2)=1 and IUC(3)=-1, then data is
retrieved for channels 0 and 1 of the UET only.
If IUC(1)=-1 then data is returned for all channels (in this case
the results are the same as if routine SPKT had been called instead).
GSTB(MAX,NI4,NSTYP,NX,NY,NZ,NV,NER)
Retrieve the Status Table for the current data set.
MAX : Maximum size of Status Table
NI4 : Integer array to contain Status Table (of size MAX)
NSTYP : Type of Status Table (1,2,3 etc.)
NX : No. of X-variables in Status Table (or no. of entries)
NY : No. of columns in Status Table (or no. of pointers)
NZ : No. of Z-variables in Status Table
NV : No. of variable values in Status Table (Type-1 table only)
NER : Error code, normally zero.
MAX must be supplied by the calling program, while NI4, NSTYP, NX,
NY, NZ, NV and NER will be returned by this routine. Note : NI4 is a
single-dimensioned array.
For type-1 Status Tables, NX will contain the number of entries
in the table, and NY will contain the "number of pointers" for each entry.
NZ should be ignored.
INITSC must be called before this routine.
VRANG(KODE,VARV,IVARV,NER)
Retrieve the range, etc., of specified RA-variable for current
data set.
KODE : if=1 then X-variable, if=2 then Y-var, if=3 then Z-var
VARV : 4-word real array in which values will be returned
Interpreted as follows :
(1) Low (2) High (3) Increment (4) Steps/Octave
IVARV : 2-word integer array, will contain the following :
(1) if=1 then linear steps, if=2 then log steps
(2) order of presentation, if =1 then low-to-high
if=2 then high-to-low, if=3 then random
NER : Error code, normally zero.
KODE must be supplied by the calling program, while VARV, IVARV
and NER will be returned.
INITSC must be called before this routine.
VNAME(NUMV,NAMV,NER)
Get number of variables, and names of the variables for current
data set.
NUMV : Number of variables
NAMV : Names of variables (character*8 array of dimension
at least NUMV)
NER : Error code, normally zero.
NUMV, NAMV and NER are returned by the routine.
It is recommended that array NAMV be dimensioned to at least 10.
INITSC must be called before this routine.
IRGV(NAMV,NAMG,NOCR,I4,NER)
Retrieve the integer*4 value of the specified variable which
occurs within a specified "repeating group".
NAMV : Variable name (type character string) (8 chars)
NAMG : Repeating group name (type character string) (8 chars)
NOCR : Occurrence number of repeating group (1,2,3...etc.)
I4 : Integer*4 value
NER : Error code, normally zero.
NAMV, NAMG and NOCR must be supplied by the calling program, while
I4 and NER will be returned.
INITSC must be called before this routine.
RRGV(NAMV,NAMG,NOCR,VAL,NER)
Retrieve the "real" value of the specified variable which occurs
within a specified "repeating group".
NAMV : Variable name (type character string) (8 chars)
NAMG : Repeating group name (type character string) (8 chars)
NOCR : Occurrence number of repeating group (1,2,3...etc.)
VAL : Real value
NER : Error code, normally zero.
NAMV, NAMG and NOCR must be supplied by the calling program, while
VAL and NER will be returned.
INITSC must be called before this routine.
HARVAX(NAMFIL,LUN,KODE,NER)
Check whether specified data file is Harris or VAX format.
NAMFIL : Data file name (integer array - last byte must be zero)
LUN : Logical unit number to assign to data file
KODE : File type : if=1 then VAX format, if=2 then Harris
NER : Error code, normally zero.
NAMFIL and LUN must be supplied, while KODE and NER will be
returned by this routine.
RSPKT(LOCA,NTRN,NREP,INDX,MAX,BUF,NS,NER)
Read the spike time data for specified trial number.
LOCA : Location (word no.) rel to start of data set, of
start of spike data header
NTRN : Trial number for which data to be retrieved
NREP : Total number of reps for this sequence
INDX : Index into spike train (1,2,3..) (i.e. buffer number)
MAX : Max. no. of spikes than can be retrieved (size of BUF)
BUF : Real array to hold spikes times (of size MAX)
NS : Number of spikes actually retrieved
NER : Error code, normally zero.
LOCA, NTRN, NREP, INDX and MAX must be supplied, while BUF, NS and
NER will be returned. The spikes times are returned in units of
millisecs. INDX determines which block of MAX spikes to get. If INDX=1
then the first MAX spikes, if =2 then the second MAX spikes (for trial
no. NTRN), etc.
INITSC must be called before this routine.
GLVS(LOCT4,NV,LOCR4,LENC,NER)
Get location of NV'th vector string starting at location LOCT4.
LOCT4 : Word location rel. to start of data set
NV : String vector number (1,2,3,...etc.)
LOCR4 : Location of NV'th vector (rel to start of data set)
LENC : Length (number of characters)
NER : Error code, normally zero.
LOCT4 and NV must ber supplied, LOCR4, LENC and NER will be
returned by this routine.
It is assumed that all intervening variables are type "vector
string".
INITSC must be called before this routine.
RDID(NER)
Read ID-list from data file directory into memory.
NER : Error code, normally zero.
This routine reads the entire list of data set ID's for the
current file into a memory buffer. This can then be followed by calls to
routine MDID (below) for fast lookup of particular ID's. This is a
special purpose routine and should be used only when fast lookup of ID's
is desired.
INITDF or INITRF must be called before this routine.
MDID(ID,KODE,NER)
Search the current directory and check if entry "ID" already
exists.
ID : Data set ID to be matched (type character) (12 chars)
KODE : Returned as 0 if no match
else set equal to entry number in directory
NER : Error code, normally zero.
ID must be supplied, KODE and NER returned.
This routine is similar in function to "MDSID" above, but it works
a lot faster.
RDID must be called before this routine.
DDID(ID,NER)
Delete the specified data set ID from the current "ID Buffer" in memory.
ID : Data set ID to be removed (type character) (12 chars)
NER : Error code, normally zero.
ID must be supplied, NER will be returned. Note: this routine only
removes the DSID from the memory buffer, not from disk.
RDID must be called before this routine.
DQID(N1,N2,NER)
Delete the specified data sets from the current "ID Buffer" in memory.
N1 : Data set number FROM
N2 : Data set number TO
NER : Error code, normally zero.
N1 and N2 must be supplied, NER will be returned. Note: this
routine only removes the dataset in the range n1 to N2 from the
memory buffer, not from disk.
RDID must be called before this routine.
ADID(ID,LOCI,NER)
Add the specified data set ID to the current "ID Buffer" in memory.
ID : Data set ID to be added (type character) (12 chars)
LOCI : Location of dataset in file
NER : Error code, normally zero.
ID and LOCI must be supplied, NER will be returned. Note: this
routine only adds the DSID to the memory buffer, not to disk.
RDID must be called before this routine.
VSVL(NAME,MAX,CVAL,NCH,NER)
Retrieve the value of any vector string variable whose name is
supplied.
NAME : Variable name (type character string) (8 chars)
MAX : Max. no. of characters acceptable
CVAL : Character value (type character)
NCH : No. of characters returned
NER : Error code, normally zero.
NAME and MAX must be supplied, while CVAL, NCH and NER will be
returned.
INITSC must be called before this routine.
VSRGV(NAMV,NAMG,NOCR,MAX,CVAL,NCH,VAL,NER)
Retrieve the vector string value of the specified variable which
occurs within a specified Repeating Group.
NAMV : Variable name (type character string)
NAMG : Repeating Group name (type character string)
NOCR : Occurrence number of repeating group (1,2,3..etc.)
MAX : Max # of occurrences to retrieve
CVAL : Character value (type character)
NCH : No. of characters returned
VAL : Numerical equivalent value
(or, -909090 if unable to decipher)
NER : Error code, normally zero.
NAMV, NAMG, NOCR and MAX must be supplied, while CVAL, VAL and NER
will be returned.
INITSC (or INITSCW) must be called before this routine.
VSRGVI(INAMV,INAMG,NOCR,MAX,ICVAL,NCH,VAL,NER)
Similar to "VSRGV" (above) except here the character strings
are zero-terminated integer arrays (for compatibility with C/C++)
Thus INAMV, INAMG and ICVAL are all zero-terminated integer
or byte arrays. For further description see VSRGV above.
DAFINVS(LOC,MAX,CVAL,NCH,NER)
Read value of vector string variable starting at specified
location in data file.
LOC : Location (word #) relative to start of file
MAX : Max # of occurrences to retrieve
CVAL : Character value (type character)
NCH : No. of characters returned (in CVAL)
NER : Error code, normally zero.
LOC and MAX must be supplied, while CVAL, NCH and NER will be
returned.
INITSC or INITRF or INITDF must be called before this routine.
CRGV(NAMV,NAMG,NOCR,LEN,CVAL,NER)
Retrieve the character string value of the specified variable
which occurs within a specified "repeating group".
NAMV : Variable name (type character) (8 chars)
NAMG : Repeating Group name (type character) (8 chars)
NOCR : Occurrence number of repeating group (1,2, etc.)
LEN : No. of characters to be retrieved
CVAL : Character value (type character string)
NER : Error code, normally zero.
NAMV, NAMG, NOCR and LEN must be supplied, while CVAL and NER will
be returned.
INITSC (or INITSCW) must be called before this routine.
CRGVI(INAMV,INAMG,NOCR,LEN,ICVAL,NER)
Similar to "CRGV" (above) except here the character strings
are zero-terminated integer arrays (for compatibility with C/C++)
Thus INAMV, INAMG and ICVAL are all zero-terminated integer
or byte arrays. For further description see CRGV above.
LORG(NAMG,NAMV,NOCR,LOCRG,LENRG,LOCV,IVTYP,NER)
Get location and length of a repeating group, and also the
location and type of specified variable within that RG, for a particular
occurrence.
NAMG : name of Repeating Group (type character string) (8 chars)
NAMV : name of variable (type character string) (8 chars)
NOCR : Occurrence number of RG (1,2,3...etc.)
LOCRG : Location of NOCR'th occurrence of RG
(word # rel. to start of data set)
LENRG : Length of RG for occurrence # NOCR
LOCV : Location of variable for NOCR'th occurrence of RG
(word # rel. to start of data set)
IVTYP : Variable type code
NER : Error code, normally zero.
NAMG,NAMV and NOCR must be supplied, LOCRG, LENRG, LOCV, IVTYP and
NER are returned by this routine.
INITSC (or INITSCW) must be called before this routine.
DELOC(NAME,LOC,ITYP,LEN,NER)
Determine the location of the specified variable within the
current data set.
NAME : Variable name (type character string) (8 chars)
LOC : Location of variable (Word # rel. to start of data set)
ITYP : Type of Variable (1=Intger*4, 2=Real, 3=Alphanumeric,
4=RG, 5=Vector String, 6=Vector RG)
LEN : Length for Alpha strings. For Repeating Groups,
rightmost 16-bits = Length of RG in 32-bit words,
leftmost 16-bits = Number of occurences of RG
NER : Error code, normally zero.
NAME must be supplied, while LOC, ITYP, LEN and NER will be returned.
INITSC (or INITSCW) must be called before this routine.
DAFBSZ(NBSIZ,NER)
Set the "Read Buffer Size" for use by DAFLIB I/O routines.
NBSIZ : Buffer size in blocks (1 to 1500)
NER : Error code, normally zero.
This routine should be called before a call to INITDF, INITRF or
INITSC. This routine is for use by advanced users who understand all the
implications. Misuse could result in bad data being read in.
Note: You don't have to call this routine. DAFLIB routines will
work fine without it, using a default read buffer size of 1 block.
Back to Top
HINITRF HGETDH HDAFIN HGETESQ HSPDIR
HMDSID HINITSC HGSTB HI4VL HDELOC
HVRANG HDAFINR HRLVL HIRGV HRRGV
HVNAME HCHVL HDAFINC HRSPKT HCRGV
HSPKT HSEQV
In each case, the calling parameters and function is the same as
for routines used to access VAX data files.
/* This is the source for schema SCH006 (VMS/RSX systems) */
/* Written : 12/20/1988 (RK) */
/* Last modified : 1/19/1989 (RK) */
/* Schema for data collected with the Response Area Program */
01 SCHNAM TYPE STRING LENGTH 8
01 RECLNT /* in blocks */
01 ANID TYPE STRING LENGTH 12
01 DSID TYPE STRING LENGTH 12
01 DATE TYPE STRING LENGTH 8
01 TIME /* in 10ths of seconds since midnight */
01 EXTYP TYPE STRING LENGTH 4
/* The above completes the mandatory header */
01 UDATA /* 0=No spike data, 1=Yes spike data */
01 ADATA /* 0=No Analog data,1=Yes Analog data*/
01 CDATA /* 0=No Cyc. Histogram data, 1=Yes */
01 SDATA /* 0=No Spontaneous Activity, 1=Yes */
01 STFORM /* STATUS table format code */
01 NUMPT /* No. of pointers in STATUS table */
01 LSTAT /* Location of STATUS table */
01 NSEQ /* No. of sequences in STAT. table */
01 URATE TYPE STRING 4 OCCURS 3 TIMES /* Unit rating at three
times */
01 XVAR TYPE RG
02 LOW TYPE REAL
02 HIGH TYPE REAL
02 INC TYPE REAL /* Step size (if linear incr) */
02 SOCT TYPE REAL /* Steps per Octave (log incr) */
02 LOGLIN /* 1=Linear steps, 2=Log steps */
02 OPRES /* Order of Presentation */
01 YVAR TYPE RG
02 LOW TYPE REAL
02 HIGH TYPE REAL
02 INC TYPE REAL
02 SOCT TYPE REAL /* Steps per Octave (log incr) */
02 LOGLIN /* 1=Linear steps, 2=Log steps */
02 OPRES /* 1=Lo-Hi, 2=Hi-Lo, 3=Random */
01 ZVAR TYPE RG
02 LOW TYPE REAL
02 HIGH TYPE REAL
02 INC TYPE REAL
02 SOCT TYPE REAL /* Steps per Octave (log incr) */
02 LOGLIN /* 1=Linear steps, 2=Log steps */
02 OPRES /* 1=Lo-Hi, 2=Hi-Lo, 3=Random */
01 NUMV /* No. of variables */
01 VNAME TYPE RG OCCURS NUMV TIMES
02 NAMEV TYPE STRING 8 /* Variable name */
01 MDSS /* Master DSS number */
01 NREPMD /* No. of reps for Master DSS */
01 NUMDSS /* No. of DSSs used */
01 DSSDAT TYPE VECTOR RG OCCURS NUMDSS TIMES
02 LDSS /* Length of DSSDAT (words) */
02 DSSN /* DSS number (1 or 2) */
02 MODE /* DSS output mode */
02 MODEX /* external or prog start */
02 MODED1 /* Delay-1 mode */
02 MODED2 /* Delay-2 mode */
02 MSLAVE /* Master/slave mode
(1=master,2=slave) */
02 CONSPL /* Constant SPL code, 0=No, 1=Yes */
02 PHFLAG /* 0=Not corrected for phase, 1=Yes */
02 GWNUMP /* No. of points in GW waveform */
02 GWCORR /* if 1 then GW corrected for calib */
02 GWCODE /* GW waveform type code */
02 GWUNF /* GW noise 0=frozen, 1=unfrozen */
02 GWSINC /* GW start increment in no. points */
02 GWDIFF /* GW address diff for Cosine Noise */
02 GWRES TYPE REAL /* GW playbck res in microsecs */
02 CALID TYPE STRING 12 /* Calib ID for correction */
02 FREQ TYPE VECTOR STRING /* Carrier freq in Hz */
02 DELAY1 TYPE VECTOR STRING /* in microsecs */
02 DUR1 TYPE VECTOR STRING /* in millisecs */
02 DELAY2 TYPE VECTOR STRING /* in microsecs */
02 DUR2 TYPE VECTOR STRING /* in millisecs */
02 REPINT TYPE VECTOR STRING /* Rep time in millisec */
02 DELM TYPE VECTOR STRING /* Master delay in usec */
02 NREPS TYPE VECTOR STRING /* No. of repetitions */
02 SPL TYPE VECTOR STRING /* Initial SPL (dB) */
02 RENV TYPE VECTOR STRING /* Rise time envelope */
02 RTIME TYPE VECTOR STRING /* Rise time in msecs */
02 FENV TYPE VECTOR STRING /* Fall time envelope */
02 FTIME TYPE VECTOR STRING /* Fall time in msecs */
02 PHASE TYPE VECTOR STRING /* Initial phase (0-1) */
02 FMOD TYPE VECTOR STRING /* Modulation Freq.(Hz) */
02 PHASM TYPE VECTOR STRING /* Mod. Phase (0-1)*/
02 DMOD TYPE VECTOR STRING /* Modulation Depth (0-1)*/
02 VALM TYPE VECTOR STRING /* Mod value (-1 to +1) */
02 VALC TYPE VECTOR STRING /* Carrier Mod constant */
02 FRLOW TYPE VECTOR STRING /* Low Frequency (Hz) */
02 FRHIGH TYPE VECTOR STRING /* High Frequency (Hz) */
02 FMRISE TYPE VECTOR STRING /* Rise time,FM swp (ms)*/
02 FMDWELL TYPE VECTOR STRING /* Hold time,FM swp (ms)*/
02 FMFALL TYPE VECTOR STRING /* Fall time,FM swp (ms)*/
02 ATTSET TYPE VECTOR STRING /* Attenuator valu (dB) */
02 GWFIL TYPE VECTOR STRING /* Name,GW storage file */
02 GWID TYPE VECTOR STRING /* ID,General Waveform */
02 GWDS TYPE VECTOR STRING /* GW data set number */
02 TONLVL TYPE VECTOR STRING /* Tone level for mask
stimulus(0-1) */
02 GWLVL TYPE VECTOR STRING /* GW level for mask
stimulus (0-1) */
02 MSKSTM TYPE VECTOR STRING /* Masking Stim (TON/GW)*/
02 MODSTM TYPE VECTOR STRING /* Modul Stim (TONE/GW) */
01 TBASE TYPE REAL /* UET time base,secs */
01 ISDEL TYPE VECTOR STRING /* Inter-seq delay,msec*/
01 IXDEL TYPE VECTOR STRING /* Inter-Xvar dela,msec */
01 UNITDEL1 /* Code,units of DELAY1 (sec=10**code)*/
01 UNITDUR1 /* Code for units of DUR1 */
01 UNITDEL2 /* Code for units of DELAY2 */
01 UNITDUR2 /* Code for units of DUR2 */
01 UNITREPI /* Code for units of REPINT */
01 UNITDELM /* Code for units of DELM */
01 UNITRTIM /* Code for units of RTIME */
01 UNITFTIM /* Code for units of FTIM */
01 UNITFMR /* Code for units of FMRISE */
01 UNITFMD /* Code for units of FMDWELL */
01 UNITFMF /* Code for units of FMFALL */
01 UNITTBAS /* Code for units of TBASE */
01 UNITISD /* Code for units of ISDEL */
01 UNITIXD /* Code for units of IXDEL */
01 NUCH /* No. of UET data channels */
01 UETCH TYPE RG OCCURS NUCH TIMES
02 UCHAN /* UET channel number */
01 ASAMPT TYPE REAL /* Analog sampling time in secs */
01 ABUF /* No. of points per cycle */
01 ANCYC /* No. of cycles sampled */
01 ANSEP /* No. of cycles stored/stim point */
01 AVCODE /* 0=No averaging, 1=Yes averaging */
01 AVOLC TYPE REAL /* Voltage conversion factor */
01 AVCC TYPE REAL /* Voltage Conversion Code */
01 ANBITS /* No. of bits per sample 16/32 */
01 NACH /* No. of A/D channels */
01 ADCH TYPE RG OCCURS NACH TIMES
02 ACHAN /* A/D Channel number */
01 NUMPHT /* No. of Period (Cycle) histograms */
01 CHIST TYPE RG OCCURS NUMPHT TIMES
02 CHFREQ TYPE VECTOR STRING /* Binning Freq in Hz for
Cycle Hist.*/
02 CHNBIN /* No. of bins in Cycle Histograms */
01 LDUMMY
01 DUMMY LENGTH LDUMMY /* Extra space for future use */
01 DATA TYPE RG OCCURS NSEQ TIMES /* Spike time data */
02 TSDATA TYPE VECTOR INTEGER OCCURS NREPS TIMES
01 ADATA TYPE RG OCCURS NSEQ TIMES /* Sampled analog data */
02 ANDATA TYPE VECTOR INTEGER OCCURS ANSEP TIMES
01 CDATA TYPE RG OCCURS NSEQ TIMES /* Cycle histogram data */
02 CHDAT TYPE RG OCCURS NUMPHT TIMES
03 CHDATA TYPE VECTOR INTEGER
01 STATTB TYPE RG
02 ADDRPT OCCURS NUMPT TIMES /* Address pointer(s) */
00
Back to Top
Back to Top
Code Interpretation
---- --------------
101 Data set not found in data file
102 Invalid schema name
.This data set is not suitable for RAP analysis
103 INITSC or HINITSC must be called first
105 This is not an integer*4 variable
106 Variable name not found in schema
107 This is not a type REAL variable
108 This is not a repeating group name
109 This variable is not type "character"
110 Cannot divide by zero
115 Invalid number of repeating group occurrences
116 RG did not occur this many times
117 Variable does not occur within specified RG
118 File not suitable for RAP analysis
121 Supplied buffer is too small
122 Number of spikes exceeds buffer size
123 Variable value is undefined
127 Invalid repeating group length
128 This variable is not type "vector string"
129 This variable is not type "vector RG"
130 Error converting Harris character to VAX character string
131 Error converting Harris integer to VAX integer
132 Error converting Harris floating point to VAX floating pt.
133 Invalid repeating group occurrence number
134 Number of points is too small
135 This is not Tuning Curve data
137 Frequency increment is improper
139 Character variable number out of range
140 Improper Schema name for this operation
146 Impossible error, consult programmer
147 Error converting from integer array to character string
148 Unable to obtain value of variable
149 Unable to extract unit number from DSID
151 Too few or too many points
152 Number of points must be power of two
153 Invalid time resolution
155 Trial number is outside range specified by user
159 Specified character string is of improper length
160 Syntax error
161 Variable value is out of range
162 Too many windows
163 Too few columns
164 Invalid spike number
165 Improper analysis for this program
166 Value must be positive, non-zero
167 Invalid message number
168 Invalid Unit Event Timer channel number
173 Indexing is improper
174 Unable to form a new DSID
175 Work buffer is too small, try again, or consult programmer
201 Parameter 1 is invalid
202 Parameter 2 is invalid
203 Parameter 3 is invalid
221 Too few entries in directory
222 No entries were deleted
223 The FROM number cannot exceed the TO number
224 Invalid data set number
225 INITDF or INITRF must be called first
226 Entry already exists in directory
228 Data File directory is full
229 Bad Directory Header
231 Unable to read Event Flag, consult programmer, or try again
232 Unable to create VMS mailbox, consult programmer
241 Bad data in file
250 File Read error
251 File Write error
252 File Open error
.Please use the DIR command to check for file existence
.Also make sure you are authorized to access the file
253 Invalid Logical Unit Number
254 File name already includes directory spec
264 Invalid pointer into buffer
265 Too many real variables, Buffer is full
266 Too many character variables, Buffer is full
267 Variable already defined as a different data type
272 Too many points in Tuning Curve, buffer overflow
274 Improper number of values in line-table buffer
275 Unable to get logical unit number
280 Improper data storage format
285 No space to create temp. array, out of memory space
286 Invalid array size
289 Array is undefined
290 Array sizes are not the same
291 Invalid array number
292 This array already exists with a different size
294 A user file is already assigned to this number
.File open failed, try a different number
301 Improper STATUS table type
.This data may not be suitable for RAP analysis
303 Invalid histogram type
307 Improper number of RA variables
308 Invalid number of plots along X-direction
310 Improper number of repetitions
311 Improper number of sequences
312 Improper number of STATUS table pointers
314 Invalid time base
315 Invalid stimulus duration
316 Invalid repetition interval
317 Improper number of DSS's
318 Invalid master DSS number
319 No data recorded at this stimulus point
320 Invalid value of sync. coefficient
321 Invalid Rise/Fall envelope shape
322 Invalid units for duration time
323 Invalid units for repetition interval
324 Invalid units for delay
325 Invalid units for time base
328 Invalid repetition number
329 Only Type-2 STATUS table supported for this operation
330 STATUS Tables for the two data sets must be the same TYPE
331 Number of reps for the two data sets must be the same
332 Stimulus duration for the two data sets must be the same
333 Repetition interval for the two data sets must be the same
334 Number of RA variables for the two data sets must be same
335 Variable increments for the two data sets must be the same
337 Invalid variable type for this operation
338 Array element is out of bounds
339 Only Type-1 STATUS table supported for this operation
340 No data within specified time range
.Please pick a different range
355 Invalid number of histogram bins
356 No binning frequency specified
357 This is not one of the RA variables
360 Variable number is out of range
362 Spike time cannot be negative
363 Invalid variable name
375 Invalid binning frequency
410 Destination file format is improper
430 Keyword not found in database
443 Invalid time format, consult programmer, or try again
Back to Top
kochhar@physiology.wisc.edu.
Return to Computing Page
Back to The Basement
This page last modified on : Mar. 7, 2002