source: sans/SANSReduction/trunk/Put in User Procedures/SANS_Reduction_v5.00/VAXFileUtils.ipf @ 40

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

//**************************
// Vers. 1.2 092101
//
//this file is a collection of uilities for processing vax filenames
//and processing lists (especially for display in popup menus)
//
//required to correctly account for VAX supplied version numbers, which
//may or may not be removed by the ftp utility
//
// - parses lists of run numbers into real filenames
// - selects proper detector constants
//
//**************************


//given a filename of a SANS data filename of the form
//TTTTTnnn.SAn_TTT_Txxx
//returns the run number "nnn" as a number
//returns -1 as an invalid file number
Function GetRunNumFromFile(item)
        String item
        Variable invalid = -1   //negative numbers are invalid
        Variable num=-1
        
        //find the "dot"
        String runStr=""
        Variable pos = strsearch(item,".",0)
        if(pos == -1)
                //"dot" not found
                return (invalid)
        else
                //found, get the three characters preceeding it
                if (pos <=2)
                        //not enough characters
                        return (invalid)
                else
                        runStr = item[pos-3,pos-1]
                        //convert to a number
                        num = str2num(runStr)
                        //if valid, return it
                        if (num == NaN)
                                //3 characters were not a number
                                return (invalid)
                        else
                                //run was OK
                                return (num)
                        Endif
                Endif
        Endif
End

//given a filename of a SANS data filename of the form
//TTTTTnnn.SAn_TTT_Txxx
//returns the run number "nnn" as a STRING of THREE characters
//returns "ABC" as an invalid file number
Function/S GetRunNumStrFromFile(item)
        String item
        String invalid = "ABC"  //"ABC" is not a valid run number, since it's text
        Variable num=-1
        
        //find the "dot"
        String runStr=""
        Variable pos = strsearch(item,".",0)
        if(pos == -1)
                //"dot" not found
                return (invalid)
        else
                //found, get the three characters preceeding it
                if (pos <=2)
                        //not enough characters
                        return (invalid)
                else
                        runStr = item[pos-3,pos-1]
                        return (runStr)
                Endif
        Endif
End

//returns a string containing the full path and file to the file containing the 
//run number "num". The null string is returned if no valid file can be found
//the path "catPathName" used and is hard-wired, will abort if this path does not exist
//the file returned will be a RAW SANS data file, other types of files are 
//filtered out.
Function/S FindFileFromRunNumber(num)
        Variable num
        
        String fullName="",partialName="",item=""
        //get list of raw data files in folder that match "num" (add leading zeros)
        if( (num>999) || (num<=0) )
                //Print "error in  FindFileFromRunNumber(num), file number too large or too small"
                Return ("")
        Endif
        //make a three character string of the run number
        String numStr=""
        if(num<10)
                numStr = "00"+num2str(num)
        else
                if(num<100)
                        numStr = "0"+num2str(num)
                else
                        numStr = num2str(num)
                Endif
        Endif
        //Print "numstr = ",numstr
        
        //make sure that path exists
        PathInfo catPathName
        String path = S_path
        if (V_flag == 0)
                Abort "folder path does not exist - use Pick Path button"
        Endif
        String list="",newList="",testStr=""
        
        list = IndexedFile(catPathName,-1,"????")       //get all files in folder
        //find (the) one with the number in the run # location in the name
        Variable numItems,ii,runFound,isRAW
        numItems = ItemsInList(list,";")                //get the new number of items in the list
        ii=0
        do
                //parse through the list in this order:
                // 1 - does item contain run number (as a string) "TTTTTnnn.SAn_XXX_Tyyy"
                // 2 - exclude by isRaw? (to minimize disk access)
                item = StringFromList(ii, list  ,";" )
                if(strlen(item) != 0)
                        //find the run number, if it exists as a three character string
                        testStr = GetRunNumStrFromFile(item)
                        runFound= cmpstr(numStr,testStr)        //compare the three character strings, 0 if equal
                        if(runFound == 0)
                                //the run Number was found
                                //build valid filename
                                partialName = FindValidFileName(item)
                                if(strlen(partialName) != 0)            //non-null return from FindValidFileName()
                                        fullName = path + partialName
                                        //check if RAW, if so,this must be the file!
                                        isRAW = CheckIfRawData(fullName)
                                        if(isRaw)
                                                //stop here
                                                return(fullname)
                                        Endif
                                Endif
                        Endif
                Endif
                ii+=1
        while(ii<numItems)              //process all items in list
        Return ("")     //null return if file not found in list
End

//function to test a binary file to see if it is a RAW binary SANS file
//first checks the total bytes in the file (which for raw data is 33316 bytes)
//**note that the "DIV" file will also show up as a raw file by the run field
//should be listed in CAT/SHORT and in patch windows
//
//Function then checks the file fname (full path:file) for "RAW" run.type field
//if not found, the data is not raw data and zero is returned
Function CheckIfRawData(fname)
        String fname
        
        Variable refnum,totalBytes
        String testStr=""
        
        Open/R/T="????TEXT" refNum as fname
        //get the total number of bytes in the file, to avoid moving past EOF
        FStatus refNum
        totalBytes = V_logEOF
        //Print totalBytes
        if(totalBytes!=33316)
                //can't possibly be a raw data file
                Close refnum
                return(0)               //not a raw SANS file
        Endif
        FSetPos refNum,75
        FReadLine/N=3 refNum,testStr
        Close refNum
        
        if(cmpstr(testStr,"RAW")==0)
                //true, is raw data file
                Return(1)
        else
                //some other file
                Return(0)
        Endif
End

//function to remove all spaces from names when searching for filenames
//the filename (as saved) will never have interior spaces (TTTTTnnn_AB _Bnnn)
//but the text field in the header WILL, if less than 3 characters were used for the 
//user's initials, and can have leading spaces if prefix was less than 5 characters
//
//returns a string identical to the original string, except with the interior spaces removed
//
Function/S RemoveAllSpaces(str)
        String str
        
        String tempstr = str
        Variable ii,spc,len             //should never be more than 2 or 3 trailing spaces in a filename
        ii=0
        do
                len = strlen(tempStr)
                spc = strsearch(tempStr," ",0)          //is the last character a space?
                if (spc == -1)
                        break           //no more spaces found, get out
                endif
                str = tempstr
                tempStr = str[0,(spc-1)] + str[(spc+1),(len-1)] //remove the space from the string
        While(1)        //should never be more than 2 or 3
        
        If(strlen(tempStr) < 1)
                tempStr = ""            //be sure to return a null string if problem found
        Endif
        
        //Print strlen(tempstr)
        
        Return(tempStr)
                
End


//Function attempts to find valid filename from partial name that has been stripped of
//the VAX version number. The partial name is tried first
//*** the PATH is hard-wired to catPathName (which is assumed to exist)
//version numers up to ;10 are tried
//only the "name;vers" is returned. the path is not prepended, hence the return string
//is not a complete specification of the file
//
// added 11/99 - uppercase and lowercase versions of the file are tried, if necessary
// since from marquee, the filename field (textread[0]) must be used, and can be a mix of
// upper/lowercase letters, while the filename on the server (should) be all caps
// now makes repeated calls to ValidFileString()
//
Function/S FindValidFilename(partialName)
        String PartialName
        
        String retStr=""
        
        //try name with no changes - to allow for ABS files that have spaces in the names 12APR04
        retStr = ValidFileString(partialName)
        if(cmpstr(retStr,"") !=0)
                //non-null return
                return(retStr)
        Endif
        
        //if the partial name is derived from the file header, there can be spaces at the beginning
        //or in the middle of the filename - depending on the prefix and initials used
        //
        //remove any leading spaces from the name before starting
        partialName = RemoveAllSpaces(partialName)
        
        //try name with no spaces
        retStr = ValidFileString(partialName)
        if(cmpstr(retStr,"") !=0)
                //non-null return
                return(retStr)
        Endif
        
        //try all UPPERCASE
        partialName = UpperStr(partialName)
        retStr = ValidFileString(partialName)
        if(cmpstr(retStr,"") !=0)
                //non-null return
                return(retStr)
        Endif
        
        //try all lowercase (ret null if failure)
        partialName = LowerStr(partialName)
        retStr = ValidFileString(partialName)
        if(cmpstr(retStr,"") !=0)
                //non-null return
                return(retStr)
        else
                return(retStr)
        Endif
End

//Function attempts to find valid filename from partial name that has been stripped of
//the VAX version number. The partial name is tried first
//*** the PATH is hard-wired to catPathName (which is assumed to exist)
//version numers up to ;10 are tried
//only the "name;vers" is returned. the path is not prepended, hence the return string
//is not a complete specification of the file
//
Function/S ValidFileString(partialName)
        String partialName
        
        String tempName = "",msg=""
        Variable ii,refnum
        
        ii=0
        do
                if(ii==0)
                        //first pass, try the partialName
                        tempName = partialName
                        Open/Z/R/T="????TEXT"/P=catPathName refnum tempName     //Does open file (/Z flag)
                        if(V_flag == 0)
                                //file exists
                                Close refnum            //YES needed, 
                                break
                        endif
                else
                        tempName = partialName + ";" + num2str(ii)
                        Open/Z/R/T="????TEXT"/P=catPathName refnum tempName
                        if(V_flag == 0)
                                //file exists
                                Close refnum
                                break
                        endif
                Endif
                ii+=1
                //print "ii=",ii
        while(ii<11)
        //go get the selected bits of information, using tempName, which exists
        if(ii>=11)
                //msg = partialName + " not found. is version number > 11?"
                //DoAlert 0, msg
                //PathInfo catPathName
                //Print S_Path
                Return ("")             //use null string as error condition
        Endif
        
        Return (tempName)
End



//the following is a WaveMetrics procedure from <StrMatchList>
// MatchList(matchStr,list,sep)
// Returns the items of the list whose items match matchStr
// The lists are separated by the sep character, usually ";"
//
// matchStr may be something like "abc", in which case it is identical to CmpStr
// matchStr may also be "*" to match anything, "abc*" to match anything starting with "abc",
//      "*abc" to match anything ending with "abc".
// matchStr may also begin with "!" to indicate a match to anything not matching the rest of
//      the pattern.
// At most one "*" and one "!" are allowed in matchStr, otherwise the results are not guaranteed.
//
Function/S MyMatchList(matchStr,list,sep)
        String matchStr,list,sep
        String item,outList=""
        Variable n=strlen(list)
        Variable en,st=0
        do
                en= strsearch(list,sep,st)
                if( en < 0 )
                        if( st < n-1 )
                                en= n   // no trailing separator
                                sep=""  // don't put sep in output, either
                        else
                                break   // no more items in list
                        endif
                endif
                item=list[st,en-1]
                if( MyStrMatch(matchStr,item) == 0 )
                        outlist += item+sep
                Endif
                st=en+1 
        while (st < n ) // exit is by break, above
        return outlist
End

//the following is a WaveMetrics procedure from <StrMatchList>
// StrMatch(matchStr,str)
// Returns 0 if the pattern in matchStr matches str, else it returns 1
//
// matchStr may be something like "abc", in which case it is identical to CmpStr
// matchStr may also be "*" to match anything, "abc*" to match anything starting with "abc",
//      "*abc" to match anything ending with "abc".
// matchStr may also begin with "!" to indicate a match to anything not matching the rest of
//      the pattern.
// At most one "*" and one "!" are allowed in matchStr, otherwise the results are not guaranteed.
//
Function MyStrMatch(matchStr,str)
        String matchStr,str
        Variable match = 1              // 0 means match
        Variable invert= strsearch(matchStr,"!",0) == 0
        if( invert )
                matchStr[0,0]=""        // remove the "!"
        endif
        Variable st=0,en=strlen(str)-1
        Variable starPos= strsearch(matchStr,"*",0)
        if( starPos >= 0 )      // have a star
                if( starPos == 0 )      // at start
                        matchStr[0,0]=""                                // remove star at start
                else                                    // at end
                        matchStr[starPos,999999]=""     // remove star and rest of (ignored, illegal) pattern
                endif
                Variable len=strlen(matchStr)
                if( len > 0 )
                        if(starPos == 0)        // star at start, match must be at end
                                st=en-len+1
                        else
                                en=len-1        // star at end, match at start
                        endif
                else
                        str=""  // so that "*" matches anything
                endif
        endif
        match= !CmpStr(matchStr,str[st,en])==0  // 1 or 0
        if( invert )
                match= 1-match
        endif
        return match
End


//returns a string containing filename (WITHOUT the ;vers)
//the input string is a full path to the file (Mac-style, still works on Win in IGOR)
//with the folders separated by colons
Function/S GetFileNameFromPathNoSemi(fullPath)
        String fullPath
        
        Variable offset1,offset2
        String filename=""
        //String PartialPath
        offset1 = 0
        do
                offset2 = StrSearch(fullPath, ":", offset1)
                if (offset2 == -1)                              // no more colons ?
                        fileName = FullPath[offset1,strlen(FullPath) ]
                        //PartialPath = FullPath[0, offset1-1]
                        break
                endif
                offset1 = offset2+1
        while (1)
        
        //remove version number from name, if it's there - format should be: filename;N
        filename =  StringFromList(0,filename,";")              //returns null if error
        
        Return filename
End

//returns a string containing filename (INCLUDING the ;vers)
//the input string is a full path to the file (Mac-style, still works on Win in IGOR)
//with the folders separated by colons
Function/S GetFileNameFromPathKeepSemi(fullPath)
        String fullPath
        
        Variable offset1,offset2
        String filename
        //String PartialPath
        offset1 = 0
        do
                offset2 = StrSearch(fullPath, ":", offset1)
                if (offset2 == -1)                              // no more colons ?
                        fileName = FullPath[offset1,strlen(FullPath) ]
                        //PartialPath = FullPath[0, offset1-1]
                        break
                endif
                offset1 = offset2+1
        while (1)
        
        //keep version number from name, if it's there - format should be: filename;N
        
        Return filename
End

//given the full path and filename (fullPath), strips the data path
//(Mac-style, separated by colons) and returns this path
//this partial path is the same string that would be returned from PathInfo, for example
Function/S GetPathStrFromfullName(fullPath)
        String fullPath
        
        Variable offset1,offset2
        //String filename
        String PartialPath
        offset1 = 0
        do
                offset2 = StrSearch(fullPath, ":", offset1)
                if (offset2 == -1)                              // no more colons ?
                        //fileName = FullPath[offset1,strlen(FullPath) ]
                        PartialPath = FullPath[0, offset1-1]
                        break
                endif
                offset1 = offset2+1
        while (1)
        
        Return PartialPath
End

//given the VAX filename, pull off the first 8 characters to make a valid
//file string that can be used for naming averaged 1-d files
Function/S GetNameFromHeader(fullName)
        String fullName
        String temp, newName = ""
        Variable spc,ii=0
        
        //filename is 20 characters NNNNNxxx.SAn_NNN_NNN
        //want the first 8 characters, NNNNNxxx, then strip off any spaces at the beginning
        //NNNNN was entered as less than 5 characters
        //returns a null string if no name can be found
        do
                temp = fullname[ii,7]           //characters ii,7 of the name
                spc = strsearch(temp," ",0)
                if (spc == -1)
                        break           //no more spaces found
                endif
                ii+=1
        While(ii<8)
        
        If(strlen(temp) < 1)
                newName = ""            //be sure to return a null string if problem found
        else
                newName = temp
        Endif
        
        Return(newName)
End

//list (input) is a list, typically returned from IndexedFile()
//which is semicolon-delimited, and may contain filesnames from the VAX
//that contain version numbers, where the version number appears as a separate list item
//(and also as a non-existent file)
//these numbers must be purged from the list, especially for display in a popup
//or list processing of filenames
//the function returns the list, cleaned of version numbers (up to 11)
//raw data files will typically never have a version number other than 1.
Function/S RemoveVersNumsFromList(list)
        String list
        
        //get rid of version numbers first (up to 11)
        Variable ii,num
        String item 
        num = ItemsInList(list,";")
        ii=1
        do
                item = num2str(ii)
                list = RemoveFromList(item, list ,";" )
                ii+=1
        while(ii<12)
        
        return (list)
End

//input is a list of run numbers, and output is a list of filenames (not the full path)
//*** input list must be COMMA delimited***
//output is equivalent to selecting from the CAT table
//if some or all of the list items are valid filenames, keep them...
//if an error is encountered, notify of the offending element and return the null list
//
//output is COMMA delimited
//
// this routine is expecting that the "ask", "none" special cases are handled elsewhere
//and not passed here
Function/S ParseRunNumberList(list)
        String list
        
        String newList="",item="",tempStr=""
        Variable num,ii,runNum
        
        //expand number ranges, if any
        list = ExpandNumRanges(list)
        
        num=itemsinlist(list,",")
        
        for(ii=0;ii<num;ii+=1)
                //get the item
                item = StringFromList(ii,list,",")
                //is it already a valid filename?
                tempStr=FindValidFilename(item) //returns filename if good, null if error
                if(strlen(tempstr)!=0)
                        //valid name, add to list
                        //Print "it's a file"
                        newList += tempStr + ","
                else
                        //not a valid name
                        //is it a number?
                        runNum=str2num(item)
                        //print runnum
                        if(numtype(runNum) != 0)
                                //not a number -  maybe an error                        
                                DoAlert 0,"List item "+item+" is not a valid run number or filename. Please enter a valid number or filename."
                                return("")
                        else
                                //a run number or an error
                                tempStr = GetFileNameFromPathNoSemi( FindFileFromRunNumber(runNum) )
                                if(strlen(tempstr)==0)
                                        //file not found, error
                                        DoAlert 0,"List item "+item+" is not a valid run number. Please enter a valid number."
                                        return("")
                                else
                                        newList += tempStr + ","
                                endif
                        endif
                endif
        endfor          //loop over all items in list
        
        return(newList)
End

//takes a comma delimited list that MAY contain number range, and
//expands any range of run numbers into a comma-delimited list...
//and returns the new list - if not a range, return unchanged
Function/S ExpandNumRanges(list)
        String list
        
        String newList="",dash="-",item,str
        Variable num,ii,hasDash
        
        num=itemsinlist(list,",")
//      print num
        for(ii=0;ii<num;ii+=1)
                //get the item
                item = StringFromList(ii,list,",")
                //does it contain a dash?
                hasDash = strsearch(item,dash,0)                //-1 if no dash found
                if(hasDash == -1)
                        //not a range, keep it in the list
                        newList += item + ","
                else
                        //has a dash (so it's a range), expand (or add null)
                        newList += ListFromDash(item)           
                endif
        endfor
        
        return newList
End

//be sure to add a trailing comma to the return string...
Function/S ListFromDash(item)
        String item
        
        String numList="",loStr="",hiStr=""
        Variable lo,hi,ii
        
        loStr=StringFromList(0,item,"-")        //treat the range as a list
        hiStr=StringFromList(1,item,"-")
        lo=str2num(loStr)
        hi=str2num(hiStr)
        if( (numtype(lo) != 0) || (numtype(hi) !=0 ) || (lo > hi) )
                numList=""
                return numList
        endif
        for(ii=lo;ii<=hi;ii+=1)
                numList += num2str(ii) + ","
        endfor
        
        Return numList
End


//****************
//utilities for handling binary data - prompting for files or paths,
//moving data from one folder to another (within IGOR)
//and converting data to log or linear scale


//prompts user to choose the local folder that contains the SANS Data
//only one folder can be used, and its path is catPathName (and is a NAME, not a string)
//this will overwrite the path selection
//returns 1 if no path selected as error condition, or if user cancelled
Function PickPath()
        
        //set the global string to the selected pathname
        NewPath/O/M="pick the SANS data folder" catPathName
        if(V_Flag != 0)
                return(1)               //user cancelled
        endif
        
        PathInfo/S catPathName
        String dum = S_path
        String alertStr = ""
        alertStr = "You must set the path to Charlotte through a Mapped Network Drive, not through the Network Neighborhood"
        //alertStr += "  Please see the manual for details."
        if (V_flag == 0)
                //path does not exist - no folder selected
                String/G root:myGlobals:gCatPathStr = "no folder selected"
                return(1)
        else
                //set the global to the path (as a string)
                // need 4 \ since it is the escape character
                if(cmpstr("\\\\",dum[0,1])==0)  //Windoze user going through network neighborhood
                        DoAlert 0,alertStr
                        KillPath catPathName
                        return(1)
                endif
                String/G root:myGlobals:gCatPathStr = dum
                // these are now set in theire respective procedures, since the folders don't exist yet!
//              String/G root:myGlobals:Patch:gCatPathStr = dum //and the global used by Patch and Trans
//              String/G root:myGlobals:TransHeaderInfo:gCatPathStr = dum       //and the global used by Patch and Trans
                return(0)               //no error
        endif
End

//a utility function that prompts the user for a file (of any type)
//and returns the full path:name;vers string required to open the file
//the file is NOT opened by this routine (/D flag)
//a null string is returned if no file is selected
//"msgStr" is the message displayed in the dialog, informing the user what
//file is desired
//
Function/S PromptForPath(msgStr)
        String msgStr
        String fullPath
        Variable refnum
        
        //this just asks for the filename, doesn't open the file
        Open/D/R/T="????"/M=(msgStr) refNum
        fullPath = S_FileName           //fname is the full path
        //      Print refnum,fullPath
        
        //null string is returned in S_FileName if user cancelled, and is passed back to calling  function
        Return(fullPath)
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

//procedure is not called from anywhere, for debugging purposes only
//not for gerneral users, since it Kills data folders, requiring
//re-initialization of the experiment
//
Proc ClearWorkFolders()

        //not foolproof - will generage an error if any wavs, etc.. are in use.
        KillDataFolder root:RAW
        KillDataFolder root:SAM
        KillDataFolder root:EMP
        KillDataFolder root:BGD
        KillDataFolder root:COR
        KillDataFolder root:DIV
        KillDataFolder root:MSK
        KillDataFolder root:ABS
        KillDataFolder root:CAL
        SetDataFolder root:
        
End

//not used - but potentially very useful for ensuring that old
// data in work folders is not accidentally being used
//
Function ClearWorkFolder(type)
        String type
        
        SetDataFolder $("root:"+type)
        KillWaves/A/Z
        KillStrings/A/Z
        KillVariables/A/Z
        
        SetDataFolder root:
End


//procedure is not called from anywhere, for debugging purposes only
//not for gerneral users, but could be useful in reducon clutter
//
Proc ClearRootFolder()

        DoAlert 1,"Are you sure you want to delete everything from the root level?"
        SetDataFolder root:
        KillWaves/A/Z
        KillStrings/A/Z
        KillVariables/A/Z
        
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

//Utility function that returns the detector resolution (in cm) given information 
//from the file header
//Global values are set in the Initialize procedure
Function DetectorPixelResolution(fileStr,detStr)
        String fileStr,detStr
        
        Variable DDet
        String instr=fileStr[1,3]       //filestr is "[NGnSANSn] " or "[NGnSANSnn]" (11 characters total)
        
        NVAR PixelResNG3_ILL = root:myGlobals:PixelResNG3_ILL           //pixel resolution in cm
        NVAR PixelResNG5_ILL = root:myGlobals:PixelResNG5_ILL
        NVAR PixelResNG7_ILL = root:myGlobals:PixelResNG7_ILL
        NVAR PixelResNG3_ORNL = root:myGlobals:PixelResNG3_ORNL
        NVAR PixelResNG5_ORNL = root:myGlobals:PixelResNG5_ORNL
        NVAR PixelResNG7_ORNL = root:myGlobals:PixelResNG7_ORNL
        NVAR PixelResDefault = root:myGlobals:PixelResDefault
        
        strswitch(instr)
                case "NG3":
                        if(cmpstr(detStr, "ILL   ") == 0 )
                                DDet= PixelResNG3_ILL
                        else
                                DDet = PixelResNG3_ORNL //detector is ordella-type
                        endif
                        break
                case "NG5":
                        if(cmpstr(detStr, "ILL   ") == 0 )
                                DDet= PixelResNG5_ILL
                        else
                                DDet = PixelResNG5_ORNL //detector is ordella-type
                        endif
                        break
                case "NG7":
                        if(cmpstr(detStr, "ILL   ") == 0 )
                                DDet= PixelResNG7_ILL
                        else
                                DDet = PixelResNG7_ORNL //detector is ordella-type
                        endif
                        break
                default:                                                        
                        //return error?
                        DDet = PixelResDefault  //5mm, typical for new ORNL detectors
        endswitch
        
        return(DDet)
End

//Utility function that returns the detector deadtime (in seconds) given information 
//from the file header
//Global values are set in the Initialize procedure
Function DetectorDeadtime(fileStr,detStr)
        String fileStr,detStr
        
        Variable deadtime
        String instr=fileStr[1,3]       //filestr is "[NGnSANSn] " or "[NGnSANSnn]" (11 characters total)
        
        NVAR DeadtimeNG3_ILL = root:myGlobals:DeadtimeNG3_ILL           //pixel resolution in cm
        NVAR DeadtimeNG5_ILL = root:myGlobals:DeadtimeNG5_ILL
        NVAR DeadtimeNG7_ILL = root:myGlobals:DeadtimeNG7_ILL
        NVAR DeadtimeNG3_ORNL = root:myGlobals:DeadtimeNG3_ORNL
        NVAR DeadtimeNG5_ORNL = root:myGlobals:DeadtimeNG5_ORNL
        NVAR DeadtimeNG7_ORNL = root:myGlobals:DeadtimeNG7_ORNL
        NVAR DeadtimeDefault = root:myGlobals:DeadtimeDefault
        
        strswitch(instr)
                case "NG3":
                        if(cmpstr(detStr, "ILL   ") == 0 )
                                deadtime= DeadtimeNG3_ILL
                        else
                                deadtime = DeadtimeNG3_ORNL     //detector is ordella-type
                        endif
                        break
                case "NG5":
                        if(cmpstr(detStr, "ILL   ") == 0 )
                                deadtime= DeadtimeNG5_ILL
                        else
                                deadtime = DeadtimeNG5_ORNL     //detector is ordella-type
                        endif
                        break
                case "NG7":
                        if(cmpstr(detStr, "ILL   ") == 0 )
                                deadtime= DeadtimeNG7_ILL
                        else
                                deadtime = DeadtimeNG7_ORNL     //detector is ordella-type
                        endif
                        break
                default:                                                        
                        //return error?
                        deadtime = DeadtimeDefault      //1e-6 seconds, typical for new ORNL detectors
        endswitch
        
        return(deadtime)
End

//////////////////////
// "intelligent" differentiation of the data files based on information gathered while
// getting the FIle Catalog. Uses some waves that are generated there, but not displayed in the table
//
// See CatVSTable.ipf for where these files are created (and sorted to keep them together)
////////////

//testing - unused
//
Function/S TextWave2SemiList(textW)
        Wave/T textW
        
        String list=""
        Variable num=numpnts(textW),ii=0
        do
                list += textw[ii] + ";"
                ii+=1
        while(ii<num)
        return(list)
End

Function/S NumWave2CommaList(numW)
        Wave numW
        
        String list=""
        Variable num=numpnts(numW),ii=0
        do
                list += num2Str(numW[ii]) + ","
                ii+=1
        while(ii<num)
        return(list)
End

// utility function to convert a list (string) of semicolon-delimited
//items to a text wave
Function List2TextWave(str,tw)
        String str
        wave/T tw
        
        Variable num=ItemsinList(str,";"),ii=0
        Redimension/N=(num) tw
        do
                tw[ii] = StringFromList(ii, str ,";")
                ii+=1
        while(ii<num)
        return(0)
        
End

// generates a list of the procedure files in the experiment
// putting the results in a wave named "tw", editing and sorting the wave
//
Proc ListIncludedFiles()
        Make/O/T/N=2 tw
        String str=""
        //str = WinList("*", ";","INCLUDE:6")
        str = WinList("*", ";","WIN:128")
        List2TextWave(str,tw)
        Edit tw
        Sort tw tw
End

// returns a comma delimited list of run numbers based on the run numbers collected
// during the building of the File Catalog (why do it twice)
Function/S RunNumberList()

        Wave w= $"root:myGlobals:CatVSHeaderInfo:RunNumber"
        String list=""
        if(WaveExists(w) == 0)
                list = ""
        else
                list=NumWave2CommaList(w)
        endif
        return(list)
End

// list is a comma delimited list of run numbers, from the File Catalog
// - scan through the list and remove numbers that are not transmission files
//
Function/S isTransList(list)
        String list
        
        //scan through the list, find the corresponding point number, and see what isTrans says
        Variable ii,num,temp
        String newList=""
        num=ItemsInList(list ,",")
        for(ii=0;ii<num;ii+=1)
                temp = str2num( StringFromList(ii, list ,",") )
                if(RunNumIsTransFile(temp))
                        newList += num2str(temp) + ","
                endif
        endfor
        
        return(newList)
End

//truth if run number is a transmission file
// based on whatever is currently in the File Catalog
//
// Can't use findlevel - it assumes a monotonic RunNumber wave
Function RunNumIsTransFile(num)
        Variable num
        
        Wave isTrans = $"root:myGlobals:CatVSHeaderInfo:IsTrans"
        Wave RunNumber = $"root:myGlobals:CatVSHeaderInfo:RunNumber"
        
        if( (WaveExists(isTrans) == 0 ) ||  (WaveExists(RunNumber) == 0 ) )
                return(0)
        endif
        
        Variable pts=numpnts(RunNumber),ii
        for(ii=0;ii<pts;ii+=1)
                if(RunNumber[ii] == num)
                        return(isTrans[ii])
                endif
        endfor
//      FindLevel/P/Q RunNumber,num
//
//      if(isTrans[V_LevelX]==1)
//              return(1)
//      else
//              return(0)
//      endif
End

//truth if run number is at the given sample to detector distance
// based on whatever is currently in the File Catalog
//
// need fuzzy comparison, since SDD = 1.33 may actually be represented in FP as 1.33000004      !!!
Function RunNumIsAtSDD(num,sdd)
        Variable num,sdd
        
        Wave w = $"root:myGlobals:CatVSHeaderInfo:SDD"
        Wave RunNumber = $"root:myGlobals:CatVSHeaderInfo:RunNumber"
        
        if( (WaveExists(w) == 0 ) ||  (WaveExists(RunNumber) == 0 ) )
                return(0)
        endif
        Variable pts=numpnts(RunNumber),ii
        for(ii=0;ii<pts;ii+=1)
                if(RunNumber[ii] == num)
                        if(abs(w[ii] - sdd) < 0.001     )               //if numerically within 0.001 meter, they're the same
                                return(1)
                        else
                                return(0)
                        endif
                endif
        endfor
End


// list is a comma delimited list of run numbers, from the File Catalog
// - scan through the list and remove numbers that are not at the specified SDD
//
Function/S atSDDList(list,sdd)
        String list
        Variable sdd
        
        //scan through the list, find the corresponding point number, and see what SDD the run is at
        Variable ii,num,temp
        String newList=""
        num=ItemsInList(list ,",")
        for(ii=0;ii<num;ii+=1)
                temp = str2num( StringFromList(ii, list ,",") )
                if(RunNumIsAtSDD(temp,sdd))
                        newList += num2str(temp) + ","
                endif
        endfor
        
        return(newList)
End

//given a comma-delimited list, remove those that are trans files
//
Function/S removeTrans(list)
        String list
        
        //scan through the list, and remove those that are trans files
        Variable ii,num,temp
//      String newList=""
        num=ItemsInList(list ,",")
        for(ii=0;ii<num;ii+=1)
                temp = str2num( StringFromList(ii, list ,",") )
                if(RunNumIsTransFile(temp))
                        list = RemoveFromList(num2str(temp),list,",")
                        ii -= 1                 //item ii was just deleted (everything moves to fill in)
                        num -= 1                // and the list is shorter now
                endif
        endfor
        
        return(list)
End

Function setMREDFileList(str)
        String str
        
        SVAR/Z list = root:myGlobals:MRED:gFileNumList
        if(SVAR_Exists(list)==0)                //check for myself
                DoAlert 0,"The Multiple Reduce Panel must be open for you to use this function"
                Return(1)
        endif
        
        list = str
        
        //force an update If the SVAR exists, then the panel does too - MRED cleans up after itself when done
        DoWindow/F Multiple_Reduce_Panel                        //bring to front
        MRedPopMenuProc("MRFilesPopup",0,"")            //parse the list, pop the menu
        
        return(0)
End

Proc FillEMPUsingSelection()
        FillEMPFilenameWSelection()
End

Proc GuessEveryTransFiles(num)
        Variable num=6
        GuessAllTransFiles(num)
End

Proc GuessSelectedTransFiles(num)
        Variable num=6
        fGuessSelectedTransFiles(num)
End

Proc ClearSelectedTransAssignments()
        ClearSelectedAssignments()
End

Proc CreateRunNumList()
        String/G rStr=""
        rStr=RunNumberList()
        Print "The list is stored in root:rStr"
        print rStr
End

Proc TransList()
        String/G rStr=""
        rStr=RunNumberList()
        rStr=isTransList(rStr)
        print rStr
End

Proc ScatteringAtSDDList(sdd)
        Variable sdd=13
        
        String/G rStr=""
        rStr=RunNumberList()
        rStr=removeTrans(rStr)
        rStr=atSDDList(rStr,sdd)
        
        //for Igor 4, the search is case-sensitive, so use all permutations
        // in Igor 5, use the proper flag in strsearch() inside FindStringInLabel()
        rStr = RemoveEmptyBlocked(rStr,"EMPTY")
        rStr = RemoveEmptyBlocked(rStr,"Empty")
        rStr = RemoveEmptyBlocked(rStr,"empty")
        rStr = RemoveEmptyBlocked(rStr,"MT Cell")
        rStr = RemoveEmptyBlocked(rStr,"MT CELL")
        rStr = RemoveEmptyBlocked(rStr,"mt cell")
        rStr = RemoveEmptyBlocked(rStr,"BLOCKED")
        rStr = RemoveEmptyBlocked(rStr,"Blocked")
        rStr = RemoveEmptyBlocked(rStr,"blocked")
        
        print rStr
End

Proc FillMREDList()
        setMREDFileList(rStr)
        DoUpdate
End

//num passed in is the run number, as in the list
// ii is the index of all of the files from the catalog
//return will be -1 if string not found, >=0 if found
//
Function FindStringInLabel(num,findThisStr)
        Variable num
        String findThisStr
        
        Wave/T w = $"root:myGlobals:CatVSHeaderInfo:Labels"
        Wave RunNumber = $"root:myGlobals:CatVSHeaderInfo:RunNumber"
        
        if( (WaveExists(w) == 0 ) ||  (WaveExists(RunNumber) == 0 ) )
                return(0)
        endif
        
        Variable pts=numpnts(RunNumber),ii,loc
        for(ii=0;ii<pts;ii+=1)
                if(RunNumber[ii] == num)
                        loc = strsearch(w[ii], findThisStr, 0)                  //Igor 4 version is case-sensitive
//                      loc = strsearch(w[ii], findThisStr, 0 ,2)               //2==case insensitive, but Igor 5 specific
                        if(loc != -1)
                                Print "Remove w[ii] = ",num,"  ",w[ii]
                        endif
                endif
        endfor
        
        return(loc)             //return will be -1 if string not found, >=0 if found
end

//rStr is the global string, already atSDD (so there should be only one instance of
// empty and one instance of blocked
//
//scan through the list, and remove those that are have "empty" or "blocked" in the label
// or anything that is listed in StrToFind
//
Function/S RemoveEmptyBlocked(list,StrToFind)
        String list,StrToFind
        
        Variable ii,num,temp
        num=ItemsInList(list ,",")
        for(ii=0;ii<num;ii+=1)
                temp = str2num( StringFromList(ii, list ,",") )
                if(FindStringInLabel(temp,StrToFind) != -1)
                        list = RemoveFromList(num2str(temp),list,",")
                        ii -= 1                 //item ii was just deleted (everything moves to fill in)
                        num -= 1                // and the list is shorter now
                endif
        endfor
        //print list
        return(list)
end

// input is a single run number to remove from the list
//  - typically EC and BN - before sending to MRED
Proc RemoveRunFromList(remList)
        String remList=""
         
        rStr = RemoveFromList(remList, rStr ,",")
end