source: sans/SANSReduction/branches/kline_29MAR07/Put in User Procedures/SANS_Reduction_v5.00/NCNR_DataReadWrite.ipf @ 69

#pragma rtGlobals=1             // Use modern global access method.
#pragma version=5.0
#pragma IgorVersion = 5.0

//**************************
//
// Vers. 1.2 092101
// Vers. 5.0 29MAR07 - branched from main reduction to split out facility
//                     specific calls
//
// functions for reading raw data files from the VAX
// - RAW data files are read into the RAW folder - integer data from the detector
//   is decompressed and given the proper orientation
// - header information is placed into real,integer, or text waves in the order they appear
//   in the file header
//
// Work data (DIV File) is read into the DIV folder
//
//*****************************

//simple, main entry procedure that will load a RAW sans data file (not a work file)
//into the RAW dataFolder
//(typically called from main panel button)
//
Proc LoadSANSData()
        String msgStr = "Select a SANS data file"
        
        Variable err
        err = ReadBinarySANS(msgStr)            //will prompt for file
        //ignore the error here 
End


//function called by the main entry procedure
//sets global display variable, reads in the data, and displays it
//displays alert, and returns error if no file was selected
//
// calling routine must decide whether to abort the execution or not...
Function ReadBinarySANS(msgStr)
        String msgStr

        String filename=""

        //each routine is responsible for checking the current (displayed) data folder
        //selecting it, and returning to root when done
        PathInfo/S catPathName          //should set the next dialog to the proper path...
        //get the filename, then read it in
        filename = PromptForPath(msgStr)
        //check for cancel from dialog
        if(strlen(filename)==0)
                //user cancelled, abort
                SetDataFolder root:
                DoAlert 0, "No file selected, action aborted"
                return(1)
        Endif
        //Print  "GetFileNameFromPath(filename) = " +  GetFileNameFromPathNoSemi(filename)
        ReadHeaderAndData(filename)     //this is the full Path+file

        //the calling macro must change the display type
        String/G root:myGlobals:gDataDisplayType="RAW"          //displayed data type is raw
        
        //data is displayed here
        fRawWindowHook()
        
        Return(0)
End

//function that does the guts of reading the binary data file
//fname is the full path:name;vers required to open the file
//VAX record markers are skipped as needed
//the data as read in is in compressed I*2 format, and is decompressed
//immediately after being read in. The final root:RAW:data wave is the real
//neutron counts and can be directly operated on
//header information is put into three wave, integers,reals, and text
//logicals in the header are currently skipped, since they are no use in the 
//data reduction process. the logicals, however are left untouched.
//
Function ReadHeaderAndData(fname)
        String fname
        //this function is for reading in RAW data only, so it will always put data in RAW folder
        String curPath = "root:RAW"
        SetDataFolder curPath           //use the full path, so it will always work
        Variable/G root:RAW:gIsLogScale = 0             //initial state is linear, keep this in RAW folder
        
        Variable refNum,integer,realval
        String sansfname,textstr
        
        Make/O/N=23 $"root:RAW:IntegersRead"
        Make/O/N=52 $"root:RAW:RealsRead"
        Make/O/T/N=11 $"root:RAW:TextRead"
        
        Wave intw=$"root:RAW:IntegersRead"
        Wave realw=$"root:RAW:RealsRead"
        Wave/T textw=$"root:RAW:TextRead"
        
        //***NOTE ****
        // the "current path" gets mysteriously reset to "root:" after the SECOND pass through
        // this read routine, after the open dialog is presented
        // the "--read" waves end up in the correct folder, but the data does not! Why?
        //must re-set data folder before writing data array (done below)
        
        //full filename and path is now passed in...
        //actually open the file
        Open/R refNum as fname
        //skip first two bytes (VAX record length markers, not needed here)
        FSetPos refNum, 2
        //read the next 21 bytes as characters (fname)
        FReadLine/N=21 refNum,textstr
        textw[0]= textstr
        //read four i*4 values  /F=3 flag, B=3 flag
        FBinRead/F=3/B=3 refNum, integer
        intw[0] = integer
        //
        FBinRead/F=3/B=3 refNum, integer
        intw[1] = integer
        //
        FBinRead/F=3/B=3 refNum, integer
        intw[2] = integer
        //
        FBinRead/F=3/B=3 refNum, integer
        intw[3] = integer
        // 6 text fields
        FSetPos refNum,55               //will start reading at byte 56
        FReadLine/N=20 refNum,textstr
        textw[1]= textstr
        FReadLine/N=3 refNum,textstr
        textw[2]= textstr
        FReadLine/N=11 refNum,textstr
        textw[3]= textstr
        FReadLine/N=1 refNum,textstr
        textw[4]= textstr
        FReadLine/N=8 refNum,textstr
        textw[5]= textstr
        FReadLine/N=60 refNum,textstr
        textw[6]= textstr
        
        //3 integers
        FSetPos refNum,174
        FBinRead/F=3/B=3 refNum, integer
        intw[4] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[5] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[6] = integer
        
        //2 integers, 3 text fields
        FSetPos refNum,194
        FBinRead/F=3/B=3 refNum, integer
        intw[7] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[8] = integer
        FReadLine/N=6 refNum,textstr
        textw[7]= textstr
        FReadLine/N=6 refNum,textstr
        textw[8]= textstr
        FReadLine/N=6 refNum,textstr
        textw[9]= textstr
        
        //2 integers
        FSetPos refNum,244
        FBinRead/F=3/B=3 refNum, integer
        intw[9] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[10] = integer
        
        //2 integers
        FSetPos refNum,308
        FBinRead/F=3/B=3 refNum, integer
        intw[11] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[12] = integer
        
        //2 integers
        FSetPos refNum,332
        FBinRead/F=3/B=3 refNum, integer
        intw[13] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[14] = integer
        
        //3 integers
        FSetPos refNum,376
        FBinRead/F=3/B=3 refNum, integer
        intw[15] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[16] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[17] = integer
        
        //1 text field
        FSetPos refNum,404
        FReadLine/N=42 refNum,textstr
        textw[10]= textstr
        
        //1 integer
        FSetPos refNum,458
        FBinRead/F=3/B=3 refNum, integer
        intw[18] = integer
        
        //4 integers
        FSetPos refNum,478
        FBinRead/F=3/B=3 refNum, integer
        intw[19] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[20] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[21] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[22] = integer
        
        Close refNum
        
        //now get all of the reals
        //
        //Do all the GBLoadWaves at the end
        //
        //FBinRead Cannot handle 32 bit VAX floating point
        //GBLoadWave, however, can properly read it
        String GBLoadStr="GBLoadWave/O/N=tempGBwave/T={2,2}/J=2/W=1/Q"
        String strToExecute
        //append "/S=offset/U=numofreals" to control the read
        // then append fname to give the full file path
        // then execute
        
        Variable a=0,b=0
        
        SetDataFolder curPath
        
        // 4 R*4 values
        strToExecute = GBLoadStr + "/S=39/U=4" + "\"" + fname + "\""
        Execute strToExecute
        Wave w=$"root:RAW:tempGBWave0"
        b=4     //num of reals read
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 4 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=158/U=4" + "\"" + fname + "\""
        Execute strToExecute
        b=4     
        realw[a,a+b-1] = w[p-a]
        a+=b

///////////
        // 2 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=186/U=2" + "\"" + fname + "\""
        Execute strToExecute
        b=2     
        realw[a,a+b-1] = w[p-a]
        a+=b

        // 6 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=220/U=6" + "\"" + fname + "\""
        Execute strToExecute
        b=6     
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 13 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=252/U=13" + "\"" + fname + "\""
        Execute strToExecute
        b=13
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 3 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=320/U=3" + "\"" + fname + "\""
        Execute strToExecute
        b=3     
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 7 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=348/U=7" + "\"" + fname + "\""
        Execute strToExecute
        b=7
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 4 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=388/U=4" + "\"" + fname + "\""
        Execute strToExecute
        b=4     
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 2 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=450/U=2" + "\"" + fname + "\""
        Execute strToExecute
        b=2
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 2 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=470/U=2" + "\"" + fname + "\""
        Execute strToExecute
        b=2
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 5 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=494/U=5" + "\"" + fname + "\""
        Execute strToExecute
        b=5     
        realw[a,a+b-1] = w[p-a]
        
        //if the binary VAX data ws transferred to a MAC, all is OK
        //if the data was trasnferred to an Intel machine (IBM), all the real values must be
        //divided by 4 to get the correct floating point values
        // I can't find any combination of settings in GBLoadWave or FBinRead to read data in correctly
        // on an Intel machine.
        //With the corrected version of GBLoadWave XOP (v. 1.43 or higher) Mac and PC both read
        //VAX reals correctly, and no checking is necessary 12 APR 99
        //if(cmpstr("Macintosh",IgorInfo(2)) == 0)
                //do nothing
        //else
                //either Windows or Windows NT
                //realw /= 4
        //endif
        
        SetDataFolder curPath
        //read in the data
        strToExecute = "GBLoadWave/O/N=tempGBwave/B/T={16,2}/S=514/Q" + "\"" + fname + "\""
        Execute strToExecute

        SetDataFolder curPath           //use the full path, so it will always work
        
        Make/O/N=16384 $"root:RAW:data"
        WAVE data=$"root:RAW:data"
        SkipAndDecompressVAX(w,data)
        Redimension/N=(128,128) data                    //NIST raw data is 128x128 - do not generalize
        
        //keep a string with the filename in the RAW folder
        String/G root:RAW:fileList = textw[0]
        
        //set the globals to the detector dimensions (pixels)
        Variable/G root:myGlobals:gNPixelsX=128         //default for Ordela data (also set in Initialize.ipf)
        Variable/G root:myGlobals:gNPixelsY=128
//      if(cmpstr(textW[9],"ILL   ")==0)                //override if OLD Cerca data
//              Variable/G root:myGlobals:gNPixelsX=64
//              Variable/G root:myGlobals:gNPixelsY=64
//      endif
        
        //clean up - get rid of w = $"root:RAW:tempGBWave0"
        KillWaves/Z w
        
        //return the data folder to root
        SetDataFolder root:
        
        Return 0

End


//function to take the I*2 data that was read in, in VAX format
//where the integers are "normal", but there are 2-byte record markers
//sprinkled evenly through the data
//there are skipped, leaving 128x128=16384 data values
//the input array (in) is larger than 16384
//(out) is 128x128 data (single precision) as defined in ReadHeaderAndData()
//
Function SkipAndDecompressVAX(in,out)
        Wave in,out
        
        Variable skip,ii

        ii=0
        skip=0
        do
                if(mod(ii+skip,1022)==0)
                        skip+=1
                endif
                out[ii] = Decompress(in[ii+skip])
                ii+=1
        while(ii<16384)
        return(0)
End

//decompresses each I*2 data value to its real I*4 value
//using the decompression routine written by Jim Ryhne, many moons ago
//
// the compression routine (not shown here, contained in the VAX fortran RW_DATAFILE.FOR) maps I4 to I2 values.
// (back in the days where disk space *really* mattered). the I4toI2 function spit out:
// I4toI2 = I4                                                          when I4 in [0,32767]
// I4toI2 = -777                                                        when I4 in [2,767,000,...]
// I4toI2 mapped to -13277 to -32768    otherwise
//
// the mapped values [-776,-1] and [-13276,-778] are not used.
// in this compression scheme, only 4 significant digits are retained (to allow room for the exponent)
// technically, the maximum value should be 2,768,499 since this maps to -32768. But this is of
// little consequence. If you have individual pixel values on the detector that are that large, you need
// to re-think your experiment.
Function Decompress(val)
        Variable val

        Variable i4,npw,ipw,ib,nd

        ib=10
        nd=4
        ipw=ib^nd
        i4=val

        if (i4 <= -ipw) 
                npw=trunc(-i4/ipw)
                i4=mod(-i4,ipw)*(ib^npw)
                return i4
        else
                return i4
        endif
End

//****************
//main entry procedure for reading a "WORK.DIV" file
//displays a quick image of the  file, to check that it's correct
//data is deposited in root:DIV data folder
//
Proc ReadWork_DIV()
//      Silent 1
        
        String fname = PromptForPath("Select detector sensitivity file")
        ReadHeaderAndWork("DIV",fname)          //puts what is read in work.div
        
        String waveStr = "root:DIV:data"
        NewImage/F/K=1/S=2 $waveStr             //this is an experimental IGOR operation
        ModifyImage '' ctab= {*,*,YellowHot,0}
        //Display;AppendImage $waveStr
        
        //change the title string to WORK.DIV, rather than PLEXnnn_TST_asdfa garbage
        String/G root:DIV:fileList = "WORK.DIV"
        
        SetDataFolder root:             //(redundant)
//      Silent 0
End


//this function is the guts of reading a binary VAX file of real (4-byte) values
// (i.e. a WORK.aaa file) 
// work files have the same header structure as RAW SANS data, just with
//different data (real, rather than compressed integer data)
//
//************
//this routine incorrectly reads in several data values where the VAX record
//marker splits the 4-byte real (at alternating record markers)
//this error seems to not be severe, but shoud be corrected (at great pain)
//************
//
Function ReadHeaderAndWork(type,fname)
        String type,fname
        
        //type is the desired folder to read the workfile to
        //this data will NOT be automatically displayed gDataDisplayType is unchanged

//      SVAR cur_folder=root:myGlobals:gDataDisplayType
        String cur_folder = type
        String curPath = "root:"+cur_folder
        SetDataFolder curPath           //use the full path, so it will always work
        
        Variable refNum,integer,realval
        String sansfname,textstr
        Variable/G $(curPath + ":gIsLogScale") = 0              //initial state is linear, keep this in DIV folder
        
        Make/O/N=23 $(curPath + ":IntegersRead")
        Make/O/N=52 $(curPath + ":RealsRead")
        Make/O/T/N=11 $(curPath + ":TextRead")
        
        WAVE intw=$(curPath + ":IntegersRead")
        WAVE realw=$(curPath + ":RealsRead")
        WAVE/T textw=$(curPath + ":TextRead")
        
        //***NOTE ****
        // the "current path" gets mysteriously reset to "root:" after the SECOND pass through
        // this read routine, after the open dialog is presented
        // the "--read" waves end up in the correct folder, but the data does not! Why?
        //must re-set data folder before writing data array (done below)
        
        SetDataFolder curPath
        
        //actually open the file
        Open/R refNum as fname
        //skip first two bytes
        FSetPos refNum, 2
        //read the next 21 bytes as characters (fname)
        FReadLine/N=21 refNum,textstr
        textw[0]= textstr
        //read four i*4 values  /F=3 flag, B=3 flag
        FBinRead/F=3/B=3 refNum, integer
        intw[0] = integer
        //
        FBinRead/F=3/B=3 refNum, integer
        intw[1] = integer
        //
        FBinRead/F=3/B=3 refNum, integer
        intw[2] = integer
        //
        FBinRead/F=3/B=3 refNum, integer
        intw[3] = integer
        // 6 text fields
        FSetPos refNum,55               //will start reading at byte 56
        FReadLine/N=20 refNum,textstr
        textw[1]= textstr
        FReadLine/N=3 refNum,textstr
        textw[2]= textstr
        FReadLine/N=11 refNum,textstr
        textw[3]= textstr
        FReadLine/N=1 refNum,textstr
        textw[4]= textstr
        FReadLine/N=8 refNum,textstr
        textw[5]= textstr
        FReadLine/N=60 refNum,textstr
        textw[6]= textstr
        
        //3 integers
        FSetPos refNum,174
        FBinRead/F=3/B=3 refNum, integer
        intw[4] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[5] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[6] = integer
        
        //2 integers, 3 text fields
        FSetPos refNum,194
        FBinRead/F=3/B=3 refNum, integer
        intw[7] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[8] = integer
        FReadLine/N=6 refNum,textstr
        textw[7]= textstr
        FReadLine/N=6 refNum,textstr
        textw[8]= textstr
        FReadLine/N=6 refNum,textstr
        textw[9]= textstr
        
        //2 integers
        FSetPos refNum,244
        FBinRead/F=3/B=3 refNum, integer
        intw[9] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[10] = integer
        
        //2 integers
        FSetPos refNum,308
        FBinRead/F=3/B=3 refNum, integer
        intw[11] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[12] = integer
        
        //2 integers
        FSetPos refNum,332
        FBinRead/F=3/B=3 refNum, integer
        intw[13] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[14] = integer
        
        //3 integers
        FSetPos refNum,376
        FBinRead/F=3/B=3 refNum, integer
        intw[15] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[16] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[17] = integer
        
        //1 text field
        FSetPos refNum,404
        FReadLine/N=42 refNum,textstr
        textw[10]= textstr
        
        //1 integer
        FSetPos refNum,458
        FBinRead/F=3/B=3 refNum, integer
        intw[18] = integer
        
        //4 integers
        FSetPos refNum,478
        FBinRead/F=3/B=3 refNum, integer
        intw[19] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[20] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[21] = integer
        FBinRead/F=3/B=3 refNum, integer
        intw[22] = integer
        
        Close refNum
        
        //now get all of the reals
        //
        //Do all the GBLoadWaves at the end
        //
        //FBinRead Cannot handle 32 bit VAX floating point
        //GBLoadWave, however, can properly read it
        String GBLoadStr="GBLoadWave/O/N=tempGBwave/T={2,2}/J=2/W=1/Q"
        String strToExecute
        //append "/S=offset/U=numofreals" to control the read
        // then append fname to give the full file path
        // then execute
        
        Variable a=0,b=0
        
        SetDataFolder curPath
        // 4 R*4 values
        strToExecute = GBLoadStr + "/S=39/U=4" + "\"" + fname + "\""
        Execute strToExecute
        
        SetDataFolder curPath
        Wave w=$(curPath + ":tempGBWave0")
        b=4     //num of reals read
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 4 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=158/U=4" + "\"" + fname + "\""
        Execute strToExecute
        b=4     
        realw[a,a+b-1] = w[p-a]
        a+=b

///////////
        // 2 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=186/U=2" + "\"" + fname + "\""
        Execute strToExecute
        b=2     
        realw[a,a+b-1] = w[p-a]
        a+=b

        // 6 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=220/U=6" + "\"" + fname + "\""
        Execute strToExecute
        b=6     
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 13 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=252/U=13" + "\"" + fname + "\""
        Execute strToExecute
        b=13
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 3 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=320/U=3" + "\"" + fname + "\""
        Execute strToExecute
        b=3     
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 7 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=348/U=7" + "\"" + fname + "\""
        Execute strToExecute
        b=7
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 4 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=388/U=4" + "\"" + fname + "\""
        Execute strToExecute
        b=4     
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 2 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=450/U=2" + "\"" + fname + "\""
        Execute strToExecute
        b=2
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 2 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=470/U=2" + "\"" + fname + "\""
        Execute strToExecute
        b=2
        realw[a,a+b-1] = w[p-a]
        a+=b
        
        // 5 R*4 values
        SetDataFolder curPath
        strToExecute = GBLoadStr + "/S=494/U=5" + "\"" + fname + "\""
        Execute strToExecute
        b=5     
        realw[a,a+b-1] = w[p-a]
        
        //if the binary VAX data ws transferred to a MAC, all is OK
        //if the data was trasnferred to an Intel machine (IBM), all the real values must be
        //divided by 4 to get the correct floating point values
        // I can't find any combination of settings in GBLoadWave or FBinRead to read data in correctly
        // on an Intel machine.
        //With the corrected version of GBLoadWave XOP (v. 1.43 or higher) Mac and PC both read
        //VAX reals correctly, and no checking is necessary 12 APR 99
        //if(cmpstr("Macintosh",IgorInfo(2)) == 0)
                //do nothing
        //else
                //either Windows or Windows NT
                //realw /= 4
        //endif
        
        //read in the data
         GBLoadStr="GBLoadWave/O/N=tempGBwave/T={2,2}/J=2/W=1/Q"

        curPath = "root:"+cur_folder
        SetDataFolder curPath           //use the full path, so it will always work
        
        Make/O/N=16384 $(curPath + ":data")
        WAVE data = $(curPath + ":data")
        
        Variable skip,ii,offset
        
        //read in a total of 16384 values (ii) 
        //as follows :
        // skip first 2 bytes
        // skip 512 byte header
        // skip first 2 bytes of data
        //(read 511 reals, skip 2b, 510 reals, skip 2b) -16 times = 16336 values
        // read the final 48 values in seperately to avoid EOF error
        
        /////////////
        SetDataFolder curPath
        skip = 0
        ii=0
        offset = 514 +2
        a=0
        do
                SetDataFolder curPath
                
                strToExecute = GBLoadStr + "/S="+num2str(offset)+"/U=511" + "\"" + fname + "\""
                Execute strToExecute
                //Print strToExecute
                b=511
                data[a,a+b-1] = w[p-a]
                a+=b
                
                offset += 511*4 +2
                
                strToExecute = GBLoadStr + "/S="+num2str(offset)+"/U=510" + "\"" + fname + "\""
                SetDataFolder curPath
                Execute strToExecute
                //Print strToExecute
                b=510
                data[a,a+b-1] = w[p-a]
                a+=b
                
                offset += 510*4 +2
                
                ii+=1
                //Print "inside do, data[2] =",data[2]
                //Print "inside do, tempGBwave0[0] = ",w[0]
        while(ii<16)
        
        // 16336 values have been read in --
        //read in last 64 values
        strToExecute = GBLoadStr + "/S="+num2str(offset)+"/U=48" + "\"" + fname + "\""
        
        SetDataFolder curPath
        Execute strToExecute
        b=48
        data[a,a+b-1] = w[p-a]
        a+=b
//
/// done reading in raw data
//
        //Print "in workdatareader , data = ", data[1][1]

        Redimension/n=(128,128) data
        
        //clean up - get rid of w = $"tempGBWave0"
        KillWaves w
        
        //divide the FP data by 4 if read from a PC (not since GBLoadWave update)
        //if(cmpstr("Macintosh",IgorInfo(2)) == 0)
                //do nothing
        //else
                //either Windows or Windows NT
                //data /= 4
        //endif
        
        //keep a string with the filename in the DIV folder
        String/G $(curPath + ":fileList") = textw[0]
        
        //return the data folder to root
        SetDataFolder root:
        
        Return(0)
End

////testing procedure that is not called anymore and is out-of-date
////with the new data structures. update before re-implementing
//Proc ReadBinaryWork()         //this procedure is not called anymore
//
////    Silent 1
//      
//      //make sure the globals are reset properly
//      Variable/G root:myGlobals:gIsLogScale=0 //image is linearly scaled to begin with
//      String/G root:myGlobals:gDataDisplayType="RAW"          //displayed data type is raw
//      
//      //each routine is responsible for checking the current (displayed) data folder
//      //selecting it, and returning to root when done
//      
//      ReadHeaderAndWork()
//
//      SetDataFolder root:RAW
//      //data is displayed here
//      Display;AppendImage data
//      
////    Silent 0
//      
//      //data folder was changed from root in this macro
//      SetDataFolder root:
//End


//

//returns a string containg the transmision stored in the file that is 
//currently in the "type" folder (not from the binary header)
//returns "none" if the value (in RealsRead) cannot be found
//
Function/S GetTrans(type)
        String type
        
        String name="root:"+type+":realsread"
        WAVE reals = $name
        if(waveExists(reals))
                return(num2str(reals[4]))
        else
                return("none")
        endif   
End

//returns a string containg the sample thickness stored in the file that is 
//currently in the "type" folder (not from the binary header)
//returns "none" if the value (in RealsRead) cannot be found
//
Function/S GetThick(type)
        String type
        
        String name="root:"+type+":realsread"
        WAVE reals = $name
        if(waveExists(reals))
                return(num2str(reals[5]))
        else
                return("none")
        endif   
End

/////*****************
////unused testing procedure for writing a 4 byte floating point value in VAX format
//Proc TestReWriteReal()
//      String Path
//      Variable value,start
//      
//      GetFileAndPath()
//      Path = S_Path + S_filename
//      
//      value = 0.2222
//      start = 158             //trans starts at byte 159
//      ReWriteReal(path,value,start)
//      
//      SetDataFolder root:
//End

//function will re-write a real value (4bytes) to the header of a RAW data file
//to ensure re-readability, the real value must be written mimicking VAX binary format
//which is done in this function
//path is the full path:file;vers to the file
//value is the real value to write
//start is the position to move the file marker to, to begin writing
//--so start is actually the "end byte" of the previous value
//
//this procedure takes care of all file open/close pairs needed
//
Function ReWriteReal(path,value,start)
        String path
        Variable value,start
        
        //Print " in F(), path = " + path
        Variable refnum,int1,int2, value4

//////
        value4 = 4*value
        
        Open/A/T="????TEXT" refnum as path
        //write IEEE FP, 4*desired value
        FSetPos refnum,start
        FBinWrite/B=3/F=4 refnum,value4         //write out as little endian
        
        //move to the end of the file
        FStatus refnum
        FSetPos refnum,V_logEOF
        //Print "Wrote end of header to " + num2str(V_filePOS)
        
        Close refnum
        
///////
        Open/R refnum as path
        //read back as two 16-bit integers
        FSetPos refnum,start
        FBinRead/B=2/F=2 refnum,int1    //read as big-endian
        FBinRead/B=2/F=2 refnum,int2
        
        //file was opened read-only
        //no need to move to the end of the file, just close it
        
        Close refnum
///////
        Open/A/T="????TEXT" refnum as path
        //write the two 16-bit integers, reversed
        FSetPos refnum,start
        FBinWrite/B=2/F=2 refnum,int2   //re-write as big endian
        FBinWrite/B=2/F=2 refnum,int1
        
        //move to the end of the file
        FStatus refnum
        FSetPos refnum,V_logEOF
        //Print "Wrote end of header to " + num2str(V_filePOS)
        
        Close refnum                            //at this point, it is as the VAX would have written it. 
        
        Return(0)
End