Ignore:
Timestamp:
Apr 14, 2016 10:20:13 AM (7 years ago)
Author:
srkline
Message:

few fixes to event mode for SANS

major changes to VSANS basic R/W routines to keep up-to-date with the latest data file definition. Still needs to be tested for correct paths, entries, etc.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • sans/Dev/trunk/NCNR_User_Procedures/Reduction/VSANS/V_HDF5_Write.ipf

    r983 r990  
    165165//////// TOP LEVEL 
    166166 
    167 // nexus version used for definitions 
    168 Function V_writeNeXus_version(fname,str) 
    169         String fname,str 
    170          
    171 //      String path = "entry:NeXus_version"      
    172          
    173         Make/O/T/N=1 tmpTW 
    174         String groupName = "/entry"     //       
    175         String varName = "NeXus_version" 
    176         tmpTW[0] = str // 
    177  
    178         variable err 
    179         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    180         if(err) 
    181                 Print "HDF write err = ",err 
    182         endif 
    183          
    184         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    185 //      err = V_KillNamedDataFolder(fname) 
    186 //      if(err) 
    187 //              Print "DataFolder kill err = ",err 
    188 //      endif 
    189                  
    190         return(err) 
    191 End 
     167//// nexus version used for definitions 
     168//Function V_writeNeXus_version(fname,str) 
     169//      String fname,str 
     170//       
     171////    String path = "entry:NeXus_version"      
     172//       
     173//      Make/O/T/N=1 tmpTW 
     174//      String groupName = "/entry"     //       
     175//      String varName = "NeXus_version" 
     176//      tmpTW[0] = str // 
     177// 
     178//      variable err 
     179//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     180//      if(err) 
     181//              Print "HDF write err = ",err 
     182//      endif 
     183//       
     184//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     185////    err = V_KillNamedDataFolder(fname) 
     186////    if(err) 
     187////            Print "DataFolder kill err = ",err 
     188////    endif 
     189//               
     190//      return(err) 
     191//End 
    192192 
    193193// TODO -- not mine, added somewhere by Nexus writer? 
     
    401401        return(err) 
    402402End 
    403                  
    404 // file write time (what is this??) 
    405 // TODO - figure out if this is supposed to be an integer or text (ISO) 
    406 Function V_writeFileWriteTime(fname,val) 
    407         String fname 
    408         Variable val 
    409          
    410         String path = "entry:file_time"  
    411          
    412         Make/O/D/N=1 wTmpWrite 
    413 //      Make/O/R/N=1 wTmpWrite 
    414         String groupName = "/entry"      
    415         String varName = "file_time" 
    416         wTmpWrite[0] = val 
    417  
    418         variable err 
    419         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    420         if(err) 
    421                 Print "HDF write err = ",err 
    422         endif 
    423         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    424 //      err = V_KillNamedDataFolder(fname) 
    425 //      if(err) 
    426 //              Print "DataFolder kill err = ",err 
    427 //      endif 
    428         return(err) 
    429 End 
     403 
     404 
     405// file name 
     406Function V_writeFile_name(fname,str) 
     407        String fname,str 
     408         
     409//      String path = "entry:file_name"  
     410 
     411        Make/O/T/N=1 tmpTW 
     412        String groupName = "/entry"     //       
     413        String varName = "file_name" 
     414        tmpTW[0] = str // 
     415 
     416        variable err 
     417        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     418        if(err) 
     419                Print "HDF write err = ",err 
     420        endif 
     421         
     422        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     423//      err = V_KillNamedDataFolder(fname) 
     424//      if(err) 
     425//              Print "DataFolder kill err = ",err 
     426//      endif 
     427                 
     428        return(err) 
     429End 
     430 
     431         
     432//// file write time (what is this??) 
     433//// TODO - figure out if this is supposed to be an integer or text (ISO) 
     434//Function V_writeFileWriteTime(fname,val) 
     435//      String fname 
     436//      Variable val 
     437//       
     438//      String path = "entry:file_time"  
     439//       
     440//      Make/O/D/N=1 wTmpWrite 
     441////    Make/O/R/N=1 wTmpWrite 
     442//      String groupName = "/entry"      
     443//      String varName = "file_time" 
     444//      wTmpWrite[0] = val 
     445// 
     446//      variable err 
     447//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     448//      if(err) 
     449//              Print "HDF write err = ",err 
     450//      endif 
     451//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     452////    err = V_KillNamedDataFolder(fname) 
     453////    if(err) 
     454////            Print "DataFolder kill err = ",err 
     455////    endif 
     456//      return(err) 
     457//End 
    430458                 
    431459// 
     
    729757end 
    730758 
    731  
     759// integer value 
    732760Function V_writeIntegral(fname,val) 
    733761        String fname 
     
    736764//      String path = "entry:control:integral" 
    737765         
    738         Make/O/D/N=1 wTmpWrite 
     766        Make/O/I/N=1 wTmpWrite 
    739767//      Make/O/R/N=1 wTmpWrite 
    740768        String groupName = "/entry/control"      
     
    782810 
    783811//monitor count 
     812// integer value 
    784813Function V_writeMonitorCount(fname,val) 
    785814        String fname 
     
    788817//      String path = "entry:control:monitor_counts"     
    789818         
    790         Make/O/D/N=1 wTmpWrite 
     819        Make/O/I/N=1 wTmpWrite 
    791820//      Make/O/R/N=1 wTmpWrite 
    792821        String groupName = "/entry/control"      
     
    807836end 
    808837 
     838//integer value 
    809839Function V_writeMonitor_preset(fname,val) 
    810840        String fname 
     
    813843//      String path = "entry:control:monitor_preset" 
    814844         
    815         Make/O/D/N=1 wTmpWrite 
     845        Make/O/I/N=1 wTmpWrite 
    816846//      Make/O/R/N=1 wTmpWrite 
    817847        String groupName = "/entry/control"      
     
    832862end 
    833863 
    834 Function V_writePreset(fname,val) 
    835         String fname 
    836         Variable val 
     864Function V_writePreset(fname,str) 
     865        String fname,str 
    837866         
    838867//      String path = "entry:control:preset" 
    839          
    840         Make/O/D/N=1 wTmpWrite 
    841 //      Make/O/R/N=1 wTmpWrite 
     868                 
     869        Make/O/T/N=1 tmpTW 
    842870        String groupName = "/entry/control"      
    843871        String varName = "preset" 
    844         wTmpWrite[0] = val 
    845  
    846         variable err 
    847         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     872        tmpTW[0] = str // 
     873 
     874        variable err 
     875        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    848876        if(err) 
    849877                Print "HDF write err = ",err 
     
    941969 
    942970////// INSTRUMENT/ATTENUATOR 
    943 // TODO 
    944 // attenuator number -- for VSANS I think I want this to be some "binary" representation  
    945 // of 4 plates in/out - so this may be an integer-> binary, or a text string (4 char) 
    946 Function V_writeAtten_number(fname,val) 
    947         String fname 
    948         Variable val 
    949          
    950 //      String path = "entry:instrument:attenuator:atten_number"         
    951          
    952         Make/O/D/N=1 wTmpWrite 
    953 //      Make/O/R/N=1 wTmpWrite 
    954         String groupName = "/entry/instrument/attenuator"        
    955         String varName = "atten_number" 
    956         wTmpWrite[0] = val 
    957  
    958         variable err 
    959         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    960         if(err) 
    961                 Print "HDF write err = ",err 
    962         endif 
    963         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    964 //      err = V_KillNamedDataFolder(fname) 
    965 //      if(err) 
    966 //              Print "DataFolder kill err = ",err 
    967 //      endif 
    968         return(err) 
    969 end 
     971// TODO - verify the format of how these are written out to the file 
     972// 
     973//Function V_writeAtten_number(fname,val) 
     974//      String fname 
     975//      Variable val 
     976//       
     977////    String path = "entry:instrument:attenuator:atten_number"         
     978//       
     979//      Make/O/D/N=1 wTmpWrite 
     980////    Make/O/R/N=1 wTmpWrite 
     981//      String groupName = "/entry/instrument/attenuator"        
     982//      String varName = "atten_number" 
     983//      wTmpWrite[0] = val 
     984// 
     985//      variable err 
     986//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     987//      if(err) 
     988//              Print "HDF write err = ",err 
     989//      endif 
     990//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     991////    err = V_KillNamedDataFolder(fname) 
     992////    if(err) 
     993////            Print "DataFolder kill err = ",err 
     994////    endif 
     995//      return(err) 
     996//end 
    970997 
    971998 
     
    10241051end 
    10251052 
     1053// desired thickness of attenuation 
     1054Function V_writeAttenuator_desiredThick(fname,val) 
     1055        String fname 
     1056        Variable val 
     1057         
     1058//      String path = "entry:instrument:attenuator:attenuator_transmission_error"        
     1059         
     1060        Make/O/D/N=1 wTmpWrite 
     1061//      Make/O/R/N=1 wTmpWrite 
     1062        String groupName = "/entry/instrument/attenuator"        
     1063        String varName = "desired_thickness" 
     1064        wTmpWrite[0] = val 
     1065 
     1066        variable err 
     1067        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1068        if(err) 
     1069                Print "HDF write err = ",err 
     1070        endif 
     1071        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1072//      err = V_KillNamedDataFolder(fname) 
     1073//      if(err) 
     1074//              Print "DataFolder kill err = ",err 
     1075//      endif 
     1076        return(err) 
     1077end 
     1078 
    10261079 
    10271080// distance from the attenuator to the sample (units??) 
     
    10511104end 
    10521105 
    1053  
    1054 // attenuator index, to use in the lookup table of transmission values 
    1055 Function V_writeAttenIndex(fname,val) 
    1056         String fname 
    1057         Variable val 
    1058          
    1059 //      String path = "entry:instrument:attenuator:index"        
    1060          
    1061         Make/O/D/N=1 wTmpWrite 
    1062 //      Make/O/R/N=1 wTmpWrite 
     1106// table of the attenuation factor error 
     1107Function V_writeAttenIndex_table_err(fname,inW) 
     1108        String fname 
     1109        Wave inW 
     1110         
     1111//      String path = "entry:instrument:attenuator:index_table" 
     1112         
     1113        Duplicate/O inW wTmpWrite        
     1114// then use redimension as needed to cast the wave to write to the specified type 
     1115// see WaveType for the proper codes  
     1116//      Redimension/T=() wTmpWrite 
     1117// -- May also need to check the dimension(s) before writing (don't trust the input) 
    10631118        String groupName = "/entry/instrument/attenuator"        
    1064         String varName = "index" 
    1065         wTmpWrite[0] = val 
    1066  
    1067         variable err 
    1068         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    1069         if(err) 
    1070                 Print "HDF write err = ",err 
    1071         endif 
    1072         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    1073 //      err = V_KillNamedDataFolder(fname) 
    1074 //      if(err) 
    1075 //              Print "DataFolder kill err = ",err 
    1076 //      endif 
    1077         return(err) 
    1078 end 
    1079  
     1119        String varName = "index_error_table" 
     1120 
     1121        variable err 
     1122        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1123        if(err) 
     1124                Print "HDF write err = ",err 
     1125        endif 
     1126        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1127//      err = V_KillNamedDataFolder(fname) 
     1128//      if(err) 
     1129//              Print "DataFolder kill err = ",err 
     1130//      endif 
     1131        return(err) 
     1132end 
    10801133 
    10811134// table of the attenuation factor 
     
    11081161 
    11091162 
    1110 // status "in or out" 
    1111 Function V_writeAttenStatus(fname,str) 
    1112         String fname,str 
    1113  
    1114 //      String path = "entry:instrument:attenuator:status" 
    1115  
    1116         Make/O/T/N=1 tmpTW 
    1117         String groupName = "/entry/instrument/attenuator"       //       
    1118         String varName = "status" 
    1119         tmpTW[0] = str // 
    1120  
    1121         variable err 
    1122         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    1123         if(err) 
    1124                 Print "HDF write err = ",err 
    1125         endif 
    1126          
    1127         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    1128 //      err = V_KillNamedDataFolder(fname) 
    1129 //      if(err) 
    1130 //              Print "DataFolder kill err = ",err 
    1131 //      endif 
    1132                  
    1133         return(err) 
    1134 End 
     1163//// status "in or out" 
     1164//Function V_writeAttenStatus(fname,str) 
     1165//      String fname,str 
     1166// 
     1167////    String path = "entry:instrument:attenuator:status" 
     1168// 
     1169//      Make/O/T/N=1 tmpTW 
     1170//      String groupName = "/entry/instrument/attenuator"       //       
     1171//      String varName = "status" 
     1172//      tmpTW[0] = str // 
     1173// 
     1174//      variable err 
     1175//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     1176//      if(err) 
     1177//              Print "HDF write err = ",err 
     1178//      endif 
     1179//       
     1180//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1181////    err = V_KillNamedDataFolder(fname) 
     1182////    if(err) 
     1183////            Print "DataFolder kill err = ",err 
     1184////    endif 
     1185//               
     1186//      return(err) 
     1187//End 
     1188 
     1189// number of attenuators actually dropped in 
     1190// an integer value 
     1191Function V_writeAtten_num_dropped(fname,val) 
     1192        String fname 
     1193        Variable val 
     1194         
     1195//      String path = "entry:instrument:attenuator:thickness"    
     1196         
     1197        Make/O/I/N=1 wTmpWrite 
     1198//      Make/O/R/N=1 wTmpWrite 
     1199        String groupName = "/entry/instrument/attenuator"        
     1200        String varName = "num_atten_dropped" 
     1201        wTmpWrite[0] = val 
     1202 
     1203        variable err 
     1204        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1205        if(err) 
     1206                Print "HDF write err = ",err 
     1207        endif 
     1208        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1209//      err = V_KillNamedDataFolder(fname) 
     1210//      if(err) 
     1211//              Print "DataFolder kill err = ",err 
     1212//      endif 
     1213        return(err) 
     1214end 
    11351215 
    11361216// thickness of the attenuator (PMMA) - units?? 
     
    13151395end 
    13161396 
     1397// integer value 
    13171398Function V_writeChopperSlits(fname,val) 
    13181399        String fname 
     
    13211402//      String path = "entry:instrument:beam:chopper:slits"      
    13221403         
    1323         Make/O/D/N=1 wTmpWrite 
     1404        Make/O/I/N=1 wTmpWrite 
    13241405//      Make/O/R/N=1 wTmpWrite 
    13251406        String groupName = "/entry/instrument/beam/chopper"      
     
    15931674end 
    15941675 
     1676 
     1677 
     1678 
     1679 
     1680 
    15951681// instrument/beam/monochromator/crystal (data folder) 
    15961682Function V_writeCrystalEnergy(fname,val) 
     
    19952081End 
    19962082 
    1997 Function V_writeVSTable(fname,inW) 
     2083Function V_writeVSTable_parameters(fname,inW) 
    19982084        String fname 
    19992085        Wave inW 
     
    20072093// -- May also need to check the dimension(s) before writing (don't trust the input) 
    20082094        String groupName = "/entry/instrument/beam/monochromator/velocity_selector"      
    2009         String varName = "table" 
    2010  
    2011         variable err 
    2012         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    2013         if(err) 
    2014                 Print "HDF write err = ",err 
    2015         endif 
    2016         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2017 //      err = V_KillNamedDataFolder(fname) 
    2018 //      if(err) 
    2019 //              Print "DataFolder kill err = ",err 
    2020 //      endif 
    2021         return(err) 
    2022 end 
    2023  
    2024 // TODO -- this is not the correct data type??? what does this mean?? 
    2025 Function V_writeVSTable_parameters(fname,val) 
    2026         String fname 
    2027         Variable val 
    2028          
    2029         String path = "entry:instrument:beam:monochromator:velocity_selector:table_parameters"   
    2030          
    2031         Make/O/D/N=1 wTmpWrite 
    2032 //      Make/O/R/N=1 wTmpWrite 
    2033         String groupName = "/entry/instrument/beam/monochromator/velocity_selector"      
    20342095        String varName = "table_parameters" 
    2035         wTmpWrite[0] = val 
    2036  
    2037         variable err 
    2038         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    2039         if(err) 
    2040                 Print "HDF write err = ",err 
    2041         endif 
    2042         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2043 //      err = V_KillNamedDataFolder(fname) 
    2044 //      if(err) 
    2045 //              Print "DataFolder kill err = ",err 
    2046 //      endif 
    2047         return(err) 
    2048 end 
    2049  
     2096 
     2097        variable err 
     2098        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     2099        if(err) 
     2100                Print "HDF write err = ",err 
     2101        endif 
     2102        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2103//      err = V_KillNamedDataFolder(fname) 
     2104//      if(err) 
     2105//              Print "DataFolder kill err = ",err 
     2106//      endif 
     2107        return(err) 
     2108end 
     2109 
     2110// TODO -- this may not exist for VSANS 
    20502111Function V_writeVS_tilt(fname,val) 
    20512112        String fname 
     
    23012362 
    23022363// instrument/beam/polarizer_analyzer (data folder) 
     2364// integer value 
    23032365Function V_writePolAnaCell_index(fname,val) 
    23042366        String fname 
     
    23072369//      String path = "entry:instrument:beam:polarizer_analyzer:cell_index" 
    23082370         
    2309         Make/O/D/N=1 wTmpWrite 
     2371        Make/O/I/N=1 wTmpWrite 
    23102372//      Make/O/R/N=1 wTmpWrite 
    23112373        String groupName = "/entry/instrument/beam/polarizer_analyzer"   
     
    24782540End 
    24792541 
     2542 
     2543 
     2544 
    24802545                                         
    24812546/////// INSTRUMENT/BEAM MONITORS 
    24822547 
    24832548//beam_monitor_low (data folder) 
     2549// integer value 
    24842550Function V_writeBeamMonLowData(fname,val) 
    24852551        String fname 
     
    24882554//      String path = "entry:instrument:beam_monitor_low:data" 
    24892555         
    2490         Make/O/D/N=1 wTmpWrite 
     2556        Make/O/I/N=1 wTmpWrite 
    24912557//      Make/O/R/N=1 wTmpWrite 
    24922558        String groupName = "/entry/instrument/beam_monitor_low"  
     
    26082674 
    26092675//beam_monitor_norm (data folder) 
     2676// integer value 
    26102677Function V_writeBeamMonNormData(fname,val) 
    26112678        String fname 
     
    26142681//      String path = "entry:instrument:beam_monitor_norm:data" 
    26152682         
    2616         Make/O/D/N=1 wTmpWrite 
     2683        Make/O/I/N=1 wTmpWrite 
    26172684//      Make/O/R/N=1 wTmpWrite 
    26182685        String groupName = "/entry/instrument/beam_monitor_norm"         
     
    27332800End 
    27342801 
    2735 //beam_stop (data folder) 
    2736 Function V_writeBeamStopDescription(fname,str) 
     2802 
     2803//beam_stop C2 (data folder) 
     2804Function V_writeBeamStopC2Description(fname,str) 
    27372805        String fname,str 
    27382806 
     
    27402808 
    27412809        Make/O/T/N=1 tmpTW 
    2742         String groupName = "/entry/instrument/beam_stop"        //       
     2810        String groupName = "/entry/instrument/beam_stop_C2"     //       
    27432811        String varName = "description" 
    27442812        tmpTW[0] = str // 
     
    27592827End 
    27602828 
    2761 Function V_writeBeamStopDist_to_det(fname,val) 
     2829Function V_writeBeamStopC2Dist_to_det(fname,val) 
    27622830        String fname 
    27632831        Variable val 
     
    27672835        Make/O/D/N=1 wTmpWrite 
    27682836//      Make/O/R/N=1 wTmpWrite 
    2769         String groupName = "/entry/instrument/beam_stop"         
     2837        String groupName = "/entry/instrument/beam_stop_C2"      
    27702838        String varName = "distance_to_detector" 
    27712839        wTmpWrite[0] = val 
     
    27842852End 
    27852853 
    2786 Function V_writeBeamStop_x_pos(fname,val) 
     2854// is this the index of which size beam stop is in position? 
     2855// integer value 
     2856Function V_writeBeamStopC2num_stop(fname,val) 
     2857        String fname 
     2858        Variable val 
     2859 
     2860//      String path = "entry:instrument:beam_stop:distance_to_detector" 
     2861         
     2862        Make/O/I/N=1 wTmpWrite 
     2863//      Make/O/R/N=1 wTmpWrite 
     2864        String groupName = "/entry/instrument/beam_stop_C2"      
     2865        String varName = "num_beamstops" 
     2866        wTmpWrite[0] = val 
     2867 
     2868        variable err 
     2869        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     2870        if(err) 
     2871                Print "HDF write err = ",err 
     2872        endif 
     2873        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2874//      err = V_KillNamedDataFolder(fname) 
     2875//      if(err) 
     2876//              Print "DataFolder kill err = ",err 
     2877//      endif 
     2878        return(err) 
     2879End 
     2880 
     2881Function V_writeBeamStopC2_x_pos(fname,val) 
    27872882        String fname 
    27882883        Variable val 
     
    27922887        Make/O/D/N=1 wTmpWrite 
    27932888//      Make/O/R/N=1 wTmpWrite 
    2794         String groupName = "/entry/instrument/beam_stop"         
     2889        String groupName = "/entry/instrument/beam_stop_C2"      
    27952890        String varName = "x_pos" 
    27962891        wTmpWrite[0] = val 
     
    28092904End 
    28102905 
    2811 Function V_writeBeamStop_y_pos(fname,val) 
     2906Function V_writeBeamStopC2_y_pos(fname,val) 
    28122907        String fname 
    28132908        Variable val 
     
    28172912        Make/O/D/N=1 wTmpWrite 
    28182913//      Make/O/R/N=1 wTmpWrite 
    2819         String groupName = "/entry/instrument/beam_stop"         
     2914        String groupName = "/entry/instrument/beam_stop_C2"      
    28202915        String varName = "y_pos" 
    28212916        wTmpWrite[0] = val 
     
    28342929End 
    28352930 
     2931 
     2932// beam stop C2 (shape) 
     2933Function V_writeBeamStopC2_height(fname,val) 
     2934        String fname 
     2935        Variable val 
     2936 
     2937//      String path = "entry:instrument:beam_stop:y0" 
     2938         
     2939        Make/O/D/N=1 wTmpWrite 
     2940//      Make/O/R/N=1 wTmpWrite 
     2941        String groupName = "/entry/instrument/beam_stop_C2/shape"        
     2942        String varName = "height" 
     2943        wTmpWrite[0] = val 
     2944 
     2945        variable err 
     2946        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     2947        if(err) 
     2948                Print "HDF write err = ",err 
     2949        endif 
     2950        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2951//      err = V_KillNamedDataFolder(fname) 
     2952//      if(err) 
     2953//              Print "DataFolder kill err = ",err 
     2954//      endif 
     2955        return(err) 
     2956End 
     2957 
     2958Function V_writeBeamStopC2_shape(fname,str) 
     2959        String fname,str 
     2960 
     2961//      String path = "entry:instrument:beam_stop:description" 
     2962 
     2963        Make/O/T/N=1 tmpTW 
     2964        String groupName = "/entry/instrument/beam_stop_C2/shape"       //       
     2965        String varName = "shape" 
     2966        tmpTW[0] = str // 
     2967 
     2968        variable err 
     2969        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     2970        if(err) 
     2971                Print "HDF write err = ",err 
     2972        endif 
     2973         
     2974        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2975//      err = V_KillNamedDataFolder(fname) 
     2976//      if(err) 
     2977//              Print "DataFolder kill err = ",err 
     2978//      endif 
     2979                 
     2980        return(err) 
     2981End 
     2982 
     2983// this is diameter if shape=CIRCLE 
     2984Function V_writeBeamStopC2_size(fname,val) 
     2985        String fname 
     2986        Variable val 
     2987 
     2988//      String path = "entry:instrument:beam_stop:y0" 
     2989         
     2990        Make/O/D/N=1 wTmpWrite 
     2991//      Make/O/R/N=1 wTmpWrite 
     2992        String groupName = "/entry/instrument/beam_stop_C2/shape"        
     2993        String varName = "size" 
     2994        wTmpWrite[0] = val 
     2995 
     2996        variable err 
     2997        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     2998        if(err) 
     2999                Print "HDF write err = ",err 
     3000        endif 
     3001        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3002//      err = V_KillNamedDataFolder(fname) 
     3003//      if(err) 
     3004//              Print "DataFolder kill err = ",err 
     3005//      endif 
     3006        return(err) 
     3007End 
     3008 
     3009Function V_writeBeamStopC2_width(fname,val) 
     3010        String fname 
     3011        Variable val 
     3012 
     3013//      String path = "entry:instrument:beam_stop:y0" 
     3014         
     3015        Make/O/D/N=1 wTmpWrite 
     3016//      Make/O/R/N=1 wTmpWrite 
     3017        String groupName = "/entry/instrument/beam_stop_C2/shape"        
     3018        String varName = "width" 
     3019        wTmpWrite[0] = val 
     3020 
     3021        variable err 
     3022        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3023        if(err) 
     3024                Print "HDF write err = ",err 
     3025        endif 
     3026        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3027//      err = V_KillNamedDataFolder(fname) 
     3028//      if(err) 
     3029//              Print "DataFolder kill err = ",err 
     3030//      endif 
     3031        return(err) 
     3032End 
     3033 
     3034// beam stop C3 (data folder) 
     3035Function V_writeBeamStopC3Description(fname,str) 
     3036        String fname,str 
     3037 
     3038//      String path = "entry:instrument:beam_stop:description" 
     3039 
     3040        Make/O/T/N=1 tmpTW 
     3041        String groupName = "/entry/instrument/beam_stop_C3"     //       
     3042        String varName = "description" 
     3043        tmpTW[0] = str // 
     3044 
     3045        variable err 
     3046        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     3047        if(err) 
     3048                Print "HDF write err = ",err 
     3049        endif 
     3050         
     3051        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3052//      err = V_KillNamedDataFolder(fname) 
     3053//      if(err) 
     3054//              Print "DataFolder kill err = ",err 
     3055//      endif 
     3056                 
     3057        return(err) 
     3058End 
     3059 
     3060Function V_writeBeamStopC3Dist_to_det(fname,val) 
     3061        String fname 
     3062        Variable val 
     3063 
     3064//      String path = "entry:instrument:beam_stop:distance_to_detector" 
     3065         
     3066        Make/O/D/N=1 wTmpWrite 
     3067//      Make/O/R/N=1 wTmpWrite 
     3068        String groupName = "/entry/instrument/beam_stop_C3"      
     3069        String varName = "distance_to_detector" 
     3070        wTmpWrite[0] = val 
     3071 
     3072        variable err 
     3073        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3074        if(err) 
     3075                Print "HDF write err = ",err 
     3076        endif 
     3077        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3078//      err = V_KillNamedDataFolder(fname) 
     3079//      if(err) 
     3080//              Print "DataFolder kill err = ",err 
     3081//      endif 
     3082        return(err) 
     3083End 
     3084 
     3085// integer value 
     3086Function V_writeBeamStopC3num_stop(fname,val) 
     3087        String fname 
     3088        Variable val 
     3089 
     3090//      String path = "entry:instrument:beam_stop:distance_to_detector" 
     3091         
     3092        Make/O/I/N=1 wTmpWrite 
     3093//      Make/O/R/N=1 wTmpWrite 
     3094        String groupName = "/entry/instrument/beam_stop_C3"      
     3095        String varName = "num_beamstops" 
     3096        wTmpWrite[0] = val 
     3097 
     3098        variable err 
     3099        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3100        if(err) 
     3101                Print "HDF write err = ",err 
     3102        endif 
     3103        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3104//      err = V_KillNamedDataFolder(fname) 
     3105//      if(err) 
     3106//              Print "DataFolder kill err = ",err 
     3107//      endif 
     3108        return(err) 
     3109End 
     3110 
     3111Function V_writeBeamStopC3_x_pos(fname,val) 
     3112        String fname 
     3113        Variable val 
     3114 
     3115//      String path = "entry:instrument:beam_stop:x0" 
     3116         
     3117        Make/O/D/N=1 wTmpWrite 
     3118//      Make/O/R/N=1 wTmpWrite 
     3119        String groupName = "/entry/instrument/beam_stop_C3"      
     3120        String varName = "x_pos" 
     3121        wTmpWrite[0] = val 
     3122 
     3123        variable err 
     3124        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3125        if(err) 
     3126                Print "HDF write err = ",err 
     3127        endif 
     3128        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3129//      err = V_KillNamedDataFolder(fname) 
     3130//      if(err) 
     3131//              Print "DataFolder kill err = ",err 
     3132//      endif 
     3133        return(err) 
     3134End 
     3135 
     3136Function V_writeBeamStopC3_y_pos(fname,val) 
     3137        String fname 
     3138        Variable val 
     3139 
     3140//      String path = "entry:instrument:beam_stop:y0" 
     3141         
     3142        Make/O/D/N=1 wTmpWrite 
     3143//      Make/O/R/N=1 wTmpWrite 
     3144        String groupName = "/entry/instrument/beam_stop_C3"      
     3145        String varName = "y_pos" 
     3146        wTmpWrite[0] = val 
     3147 
     3148        variable err 
     3149        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3150        if(err) 
     3151                Print "HDF write err = ",err 
     3152        endif 
     3153        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3154//      err = V_KillNamedDataFolder(fname) 
     3155//      if(err) 
     3156//              Print "DataFolder kill err = ",err 
     3157//      endif 
     3158        return(err) 
     3159End 
     3160 
     3161 
     3162// beam stop C3 (shape) 
     3163Function V_writeBeamStopC3_height(fname,val) 
     3164        String fname 
     3165        Variable val 
     3166 
     3167//      String path = "entry:instrument:beam_stop:y0" 
     3168         
     3169        Make/O/D/N=1 wTmpWrite 
     3170//      Make/O/R/N=1 wTmpWrite 
     3171        String groupName = "/entry/instrument/beam_stop_C3/shape"        
     3172        String varName = "height" 
     3173        wTmpWrite[0] = val 
     3174 
     3175        variable err 
     3176        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3177        if(err) 
     3178                Print "HDF write err = ",err 
     3179        endif 
     3180        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3181//      err = V_KillNamedDataFolder(fname) 
     3182//      if(err) 
     3183//              Print "DataFolder kill err = ",err 
     3184//      endif 
     3185        return(err) 
     3186End 
     3187 
     3188Function V_writeBeamStopC3_shape(fname,str) 
     3189        String fname,str 
     3190 
     3191//      String path = "entry:instrument:beam_stop:description" 
     3192 
     3193        Make/O/T/N=1 tmpTW 
     3194        String groupName = "/entry/instrument/beam_stop_C3/shape"       //       
     3195        String varName = "shape" 
     3196        tmpTW[0] = str // 
     3197 
     3198        variable err 
     3199        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     3200        if(err) 
     3201                Print "HDF write err = ",err 
     3202        endif 
     3203         
     3204        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3205//      err = V_KillNamedDataFolder(fname) 
     3206//      if(err) 
     3207//              Print "DataFolder kill err = ",err 
     3208//      endif 
     3209                 
     3210        return(err) 
     3211End 
     3212 
     3213// this is diameter if shape=CIRCLE 
     3214Function V_writeBeamStopC3_size(fname,val) 
     3215        String fname 
     3216        Variable val 
     3217 
     3218//      String path = "entry:instrument:beam_stop:y0" 
     3219         
     3220        Make/O/D/N=1 wTmpWrite 
     3221//      Make/O/R/N=1 wTmpWrite 
     3222        String groupName = "/entry/instrument/beam_stop_C3/shape"        
     3223        String varName = "size" 
     3224        wTmpWrite[0] = val 
     3225 
     3226        variable err 
     3227        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3228        if(err) 
     3229                Print "HDF write err = ",err 
     3230        endif 
     3231        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3232//      err = V_KillNamedDataFolder(fname) 
     3233//      if(err) 
     3234//              Print "DataFolder kill err = ",err 
     3235//      endif 
     3236        return(err) 
     3237End 
     3238 
     3239Function V_writeBeamStopC3_width(fname,val) 
     3240        String fname 
     3241        Variable val 
     3242 
     3243//      String path = "entry:instrument:beam_stop:y0" 
     3244         
     3245        Make/O/D/N=1 wTmpWrite 
     3246//      Make/O/R/N=1 wTmpWrite 
     3247        String groupName = "/entry/instrument/beam_stop_C3/shape"        
     3248        String varName = "width" 
     3249        wTmpWrite[0] = val 
     3250 
     3251        variable err 
     3252        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3253        if(err) 
     3254                Print "HDF write err = ",err 
     3255        endif 
     3256        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3257//      err = V_KillNamedDataFolder(fname) 
     3258//      if(err) 
     3259//              Print "DataFolder kill err = ",err 
     3260//      endif 
     3261        return(err) 
     3262End 
     3263 
     3264 
     3265 
    28363266//// INSTRUMENT/COLLIMATOR 
    2837 //collimator (data folder) 
    2838 Function V_writeNumberOfGuides(fname,val) 
    2839         String fname 
    2840         Variable val 
    2841          
     3267//collimator (data folder) -- this is a TEXT field 
     3268Function V_writeNumberOfGuides(fname,str) 
     3269        String fname,str 
     3270 
    28423271//      String path = "entry:instrument:collimator:number_guides" 
    2843          
    2844         Make/O/D/N=1 wTmpWrite 
    2845 //      Make/O/R/N=1 wTmpWrite 
     3272 
     3273        Make/O/T/N=1 tmpTW 
    28463274        String groupName = "/entry/instrument/collimator"        
    28473275        String varName = "number_guides" 
    2848         wTmpWrite[0] = val 
    2849  
    2850         variable err 
    2851         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    2852         if(err) 
    2853                 Print "HDF write err = ",err 
    2854         endif 
    2855         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2856 //      err = V_KillNamedDataFolder(fname) 
    2857 //      if(err) 
    2858 //              Print "DataFolder kill err = ",err 
    2859 //      endif 
    2860         return(err) 
    2861 End 
     3276        tmpTW[0] = str // 
     3277 
     3278        variable err 
     3279        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     3280        if(err) 
     3281                Print "HDF write err = ",err 
     3282        endif 
     3283         
     3284        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3285//      err = V_KillNamedDataFolder(fname) 
     3286//      if(err) 
     3287//              Print "DataFolder kill err = ",err 
     3288//      endif 
     3289                 
     3290        return(err) 
     3291End 
     3292 
    28623293 
    28633294//                              geometry (data folder) 
     
    29413372 
    29423373//                      converging_slits (not used) 
     3374 
     3375 
     3376 
    29433377 
    29443378 
     
    30703504End 
    30713505 
    3072  
     3506// integer value 
    30733507Function V_writeDet_pixel_num_x(fname,detStr,val) 
    30743508        String fname,detStr 
     
    30773511//      String path = "entry:instrument:detector_"+detStr+":pixel_nnum_x" 
    30783512         
    3079         Make/O/D/N=1 wTmpWrite 
     3513        Make/O/I/N=1 wTmpWrite 
    30803514//      Make/O/R/N=1 wTmpWrite 
    30813515        String groupName = "/entry/instrument/detector_"+detStr  
     
    30963530End 
    30973531 
     3532// integer value 
    30983533Function V_writeDet_pixel_num_y(fname,detStr,val) 
    30993534        String fname,detStr 
     
    31023537//      String path = "entry:instrument:detector_"+detStr+":pixel_num_y" 
    31033538         
    3104         Make/O/D/N=1 wTmpWrite 
     3539        Make/O/I/N=1 wTmpWrite 
    31053540//      Make/O/R/N=1 wTmpWrite 
    31063541        String groupName = "/entry/instrument/detector_"+detStr  
     
    31213556End 
    31223557 
    3123 // only defined for the "B" detector, and only to satisfy NXsas 
    3124 Function V_writeDet_azimuthalAngle(fname,detStr,val) 
     3558//// only defined for the "B" detector, and only to satisfy NXsas 
     3559//Function V_writeDet_azimuthalAngle(fname,detStr,val) 
     3560//      String fname,detStr 
     3561//      Variable val 
     3562// 
     3563//      if(cmpstr(detStr,"B") == 0) 
     3564////            String path = "entry:instrument:detector_"+detStr+":azimuthal_angle" 
     3565//       
     3566//              Make/O/D/N=1 wTmpWrite 
     3567//      //      Make/O/R/N=1 wTmpWrite 
     3568//              String groupName = "/entry/instrument/detector_"+detStr  
     3569//              String varName = "azimuthal_angle" 
     3570//              wTmpWrite[0] = val 
     3571// 
     3572//              variable err 
     3573//              err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3574//              if(err) 
     3575//                      Print "HDF write err = ",err 
     3576//              endif 
     3577//              // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3578////            err = V_KillNamedDataFolder(fname) 
     3579////            if(err) 
     3580////                    Print "DataFolder kill err = ",err 
     3581////            endif 
     3582//              return(err) 
     3583//      else 
     3584//              return(0) 
     3585//      endif 
     3586//End 
     3587 
     3588Function V_writeDet_beam_center_x(fname,detStr,val) 
    31253589        String fname,detStr 
    31263590        Variable val 
    31273591 
     3592//      String path = "entry:instrument:detector_"+detStr+":beam_center_x" 
     3593         
     3594        Make/O/D/N=1 wTmpWrite 
     3595//      Make/O/R/N=1 wTmpWrite 
     3596        String groupName = "/entry/instrument/detector_"+detStr  
     3597        String varName = "beam_center_x" 
     3598        wTmpWrite[0] = val 
     3599 
     3600        variable err 
     3601        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3602        if(err) 
     3603                Print "HDF write err = ",err 
     3604        endif 
     3605        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3606//      err = V_KillNamedDataFolder(fname) 
     3607//      if(err) 
     3608//              Print "DataFolder kill err = ",err 
     3609//      endif 
     3610        return(err) 
     3611End 
     3612 
     3613// fname is a local WORK folder 
     3614Function V_putDet_beam_center_x(fname,detStr,val) 
     3615        String fname,detStr 
     3616        Variable val 
     3617 
     3618//root:Packages:NIST:VSANS:RAW:entry:entry:instrument:detector_FB:beam_center_x 
     3619        String path = "root:Packages:NIST:VSANS:"+fname+":entry:" 
     3620        path += "entry:instrument:detector_"+detStr+":beam_center_x" 
     3621         
     3622        Wave/Z w = $path 
     3623        if(waveExists(w) == 0) 
     3624                return(1) 
     3625        else 
     3626        w[0] = val 
     3627                return(0) 
     3628        endif 
     3629 
     3630End 
     3631 
     3632Function V_writeDet_beam_center_y(fname,detStr,val) 
     3633        String fname,detStr 
     3634        Variable val 
     3635 
     3636//      String path = "entry:instrument:detector_"+detStr+":beam_center_y" 
     3637         
     3638        Make/O/D/N=1 wTmpWrite 
     3639//      Make/O/R/N=1 wTmpWrite 
     3640        String groupName = "/entry/instrument/detector_"+detStr  
     3641        String varName = "beam_center_y" 
     3642        wTmpWrite[0] = val 
     3643 
     3644        variable err 
     3645        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3646        if(err) 
     3647                Print "HDF write err = ",err 
     3648        endif 
     3649        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3650//      err = V_KillNamedDataFolder(fname) 
     3651//      if(err) 
     3652//              Print "DataFolder kill err = ",err 
     3653//      endif 
     3654        return(err) 
     3655End 
     3656 
     3657 
     3658// fname is a local WORK folder 
     3659Function V_putDet_beam_center_y(fname,detStr,val) 
     3660        String fname,detStr 
     3661        Variable val 
     3662 
     3663//root:Packages:NIST:VSANS:RAW:entry:entry:instrument:detector_FB:beam_center_y 
     3664        String path = "root:Packages:NIST:VSANS:"+fname+":entry:" 
     3665        path += "entry:instrument:detector_"+detStr+":beam_center_y" 
     3666         
     3667        Wave/Z w = $path 
     3668        if(waveExists(w) == 0) 
     3669                return(1) 
     3670        else 
     3671        w[0] = val 
     3672                return(0) 
     3673        endif 
     3674 
     3675End 
     3676 
     3677 
     3678// TODO -- write this function to return a WAVE with the data 
     3679// either as a wave reference, or as an input parameter 
     3680Function V_writeDetectorData(fname,detStr,inW) 
     3681        String fname,detStr 
     3682        Wave inW 
     3683 
     3684//      String path = "entry:instrument:detector_"+detStr+":data" 
     3685         
     3686        Duplicate/O inW wTmpWrite        
     3687// then use redimension as needed to cast the wave to write to the specified type 
     3688// see WaveType for the proper codes  
     3689//      Redimension/T=() wTmpWrite 
     3690// -- May also need to check the dimension(s) before writing (don't trust the input) 
     3691        String groupName = "/entry/instrument/detector_"+detStr  
     3692        String varName = "data" 
     3693 
     3694        variable err 
     3695        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3696        if(err) 
     3697                Print "HDF write err = ",err 
     3698        endif 
     3699        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3700//      err = V_KillNamedDataFolder(fname) 
     3701//      if(err) 
     3702//              Print "DataFolder kill err = ",err 
     3703//      endif 
     3704        return(err) 
     3705End 
     3706 
     3707 
     3708 
     3709///////////////////////// 
     3710 
     3711 
     3712// TODO -- write this function to return a WAVE with the data 
     3713// either as a wave reference, or as an input parameter 
     3714// ALSO -- the "B" deadtime will be a single value (probably) 
     3715//  but the tube banks will be 1D arrays of values, one per tube 
     3716Function V_writeDetector_deadtime(fname,detStr,inW) 
     3717        String fname,detStr 
     3718        Wave inW 
     3719 
     3720//      String path = "entry:instrument:detector_"+detStr+":dead_time" 
    31283721        if(cmpstr(detStr,"B") == 0) 
    3129 //              String path = "entry:instrument:detector_"+detStr+":azimuthal_angle" 
     3722                DoAlert 0,"Bad call to V_writeDetector_deadtime" 
     3723                return(0) 
     3724        else 
     3725 
     3726                Duplicate/O inW wTmpWrite        
     3727        // then use redimension as needed to cast the wave to write to the specified type 
     3728        // see WaveType for the proper codes  
     3729        //      Redimension/T=() wTmpWrite 
     3730        // -- May also need to check the dimension(s) before writing (don't trust the input) 
     3731                String groupName = "/entry/instrument/detector_"+detStr  
     3732                String varName = "dead_time" 
     3733         
     3734                variable err 
     3735                err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3736                if(err) 
     3737                        Print "HDF write err = ",err 
     3738                endif 
     3739                // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3740        //      err = V_KillNamedDataFolder(fname) 
     3741        //      if(err) 
     3742        //              Print "DataFolder kill err = ",err 
     3743        //      endif 
     3744                return(err) 
     3745        endif 
     3746End 
     3747 
     3748// dead time, a single value, only for detB 
     3749Function V_writeDetector_deadtime_B(fname,detStr,val) 
     3750        String fname,detStr 
     3751        variable val 
     3752 
     3753//      String path = "entry:instrument:detector_"+detStr+":dead_time" 
     3754        if(cmpstr(detStr,"B") == 0) 
    31303755         
    31313756                Make/O/D/N=1 wTmpWrite 
    31323757        //      Make/O/R/N=1 wTmpWrite 
    31333758                String groupName = "/entry/instrument/detector_"+detStr  
    3134                 String varName = "azimuthal_angle" 
     3759                String varName = "dead_time" 
     3760                wTmpWrite[0] = val 
     3761         
     3762                variable err 
     3763                err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3764                if(err) 
     3765                        Print "HDF write err = ",err 
     3766                endif 
     3767                // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3768        //      err = V_KillNamedDataFolder(fname) 
     3769        //      if(err) 
     3770        //              Print "DataFolder kill err = ",err 
     3771        //      endif 
     3772         
     3773                return(err)      
     3774        else 
     3775                DoAlert 0,"Bad call to V_writeDetector_deadtime_B" 
     3776                return(0) 
     3777        endif 
     3778End 
     3779 
     3780Function V_writeDetDescription(fname,detStr,str) 
     3781        String fname,detStr,str 
     3782 
     3783//      String path = "entry:instrument:detector_"+detStr+":description" 
     3784 
     3785        Make/O/T/N=1 tmpTW 
     3786        String groupName = "/entry/instrument/detector_"+detStr //       
     3787        String varName = "description" 
     3788        tmpTW[0] = str // 
     3789 
     3790        variable err 
     3791        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     3792        if(err) 
     3793                Print "HDF write err = ",err 
     3794        endif 
     3795         
     3796        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3797//      err = V_KillNamedDataFolder(fname) 
     3798//      if(err) 
     3799//              Print "DataFolder kill err = ",err 
     3800//      endif 
     3801                 
     3802        return(err) 
     3803End 
     3804 
     3805Function V_writeDet_distance(fname,detStr,val) 
     3806        String fname,detStr 
     3807        variable val 
     3808 
     3809//      String path = "entry:instrument:detector_"+detStr+":distance" 
     3810         
     3811        Make/O/D/N=1 wTmpWrite 
     3812//      Make/O/R/N=1 wTmpWrite 
     3813        String groupName = "/entry/instrument/detector_"+detStr  
     3814        String varName = "distance" 
     3815        wTmpWrite[0] = val 
     3816 
     3817        variable err 
     3818        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3819        if(err) 
     3820                Print "HDF write err = ",err 
     3821        endif 
     3822        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3823//      err = V_KillNamedDataFolder(fname) 
     3824//      if(err) 
     3825//              Print "DataFolder kill err = ",err 
     3826//      endif 
     3827        return(err) 
     3828End 
     3829 
     3830//// only defined for the "B" detector, and only to satisfy NXsas 
     3831//Function V_writeDet_equatorial_angle(fname,detStr,val) 
     3832//      String fname,detStr 
     3833//      variable val 
     3834// 
     3835//      if(cmpstr(detStr,"B") == 0) 
     3836////            String path = "entry:instrument:detector_"+detStr+":equatorial_angle" 
     3837//       
     3838//              Make/O/D/N=1 wTmpWrite 
     3839//      //      Make/O/R/N=1 wTmpWrite 
     3840//              String groupName = "/entry/instrument/detector_"+detStr  
     3841//              String varName = "equatorial_angle" 
     3842//              wTmpWrite[0] = val 
     3843// 
     3844//              variable err 
     3845//              err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3846//              if(err) 
     3847//                      Print "HDF write err = ",err 
     3848//              endif 
     3849//              // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3850////            err = V_KillNamedDataFolder(fname) 
     3851////            if(err) 
     3852////                    Print "DataFolder kill err = ",err 
     3853////            endif 
     3854//              return(err) 
     3855//      else 
     3856//              return(0) 
     3857//      endif 
     3858//End 
     3859 
     3860Function V_writeDetEventFileName(fname,detStr,str) 
     3861        String fname,detStr,str 
     3862 
     3863//      String path = "entry:instrument:detector_"+detStr+":event_file_name" 
     3864 
     3865        Make/O/T/N=1 tmpTW 
     3866        String groupName = "/entry/instrument/detector_"+detStr //       
     3867        String varName = "event_file_name" 
     3868        tmpTW[0] = str // 
     3869 
     3870        variable err 
     3871        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     3872        if(err) 
     3873                Print "HDF write err = ",err 
     3874        endif 
     3875         
     3876        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3877//      err = V_KillNamedDataFolder(fname) 
     3878//      if(err) 
     3879//              Print "DataFolder kill err = ",err 
     3880//      endif 
     3881                 
     3882        return(err) 
     3883End 
     3884 
     3885Function V_writeDet_IntegratedCount(fname,detStr,val) 
     3886        String fname,detStr 
     3887        Variable val 
     3888 
     3889//      String path = "entry:instrument:detector_"+detStr+":integrated_count" 
     3890         
     3891        Make/O/D/N=1 wTmpWrite 
     3892//      Make/O/R/N=1 wTmpWrite 
     3893        String groupName = "/entry/instrument/detector_"+detStr  
     3894        String varName = "integrated_count" 
     3895        wTmpWrite[0] = val 
     3896 
     3897        variable err 
     3898        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3899        if(err) 
     3900                Print "HDF write err = ",err 
     3901        endif 
     3902        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3903//      err = V_KillNamedDataFolder(fname) 
     3904//      if(err) 
     3905//              Print "DataFolder kill err = ",err 
     3906//      endif 
     3907        return(err) 
     3908End 
     3909 
     3910Function V_writeDet_LateralOffset(fname,detStr,val) 
     3911        String fname,detStr 
     3912        Variable val 
     3913 
     3914//      String path = "entry:instrument:detector_"+detStr+":lateral_offset" 
     3915         
     3916        Make/O/D/N=1 wTmpWrite 
     3917//      Make/O/R/N=1 wTmpWrite 
     3918        String groupName = "/entry/instrument/detector_"+detStr  
     3919        String varName = "lateral_offset" 
     3920        wTmpWrite[0] = val 
     3921 
     3922        variable err 
     3923        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3924        if(err) 
     3925                Print "HDF write err = ",err 
     3926        endif 
     3927        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3928//      err = V_KillNamedDataFolder(fname) 
     3929//      if(err) 
     3930//              Print "DataFolder kill err = ",err 
     3931//      endif 
     3932        return(err) 
     3933End 
     3934 
     3935//Function V_writeDet_VerticalOffset(fname,detStr,val) 
     3936//      String fname,detStr 
     3937//      Variable val 
     3938// 
     3939////    String path = "entry:instrument:detector_"+detStr+":vertical_offset" 
     3940//       
     3941//      Make/O/D/N=1 wTmpWrite 
     3942////    Make/O/R/N=1 wTmpWrite 
     3943//      String groupName = "/entry/instrument/detector_"+detStr  
     3944//      String varName = "vertical_offset" 
     3945//      wTmpWrite[0] = val 
     3946// 
     3947//      variable err 
     3948//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3949//      if(err) 
     3950//              Print "HDF write err = ",err 
     3951//      endif 
     3952//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3953////    err = V_KillNamedDataFolder(fname) 
     3954////    if(err) 
     3955////            Print "DataFolder kill err = ",err 
     3956////    endif 
     3957//      return(err) 
     3958//End 
     3959 
     3960//// only defined for the "B" detector, and only to satisfy NXsas 
     3961//Function V_writeDet_polar_angle(fname,detStr,val) 
     3962//      String fname,detStr 
     3963//      Variable val 
     3964// 
     3965//      if(cmpstr(detStr,"B") == 0) 
     3966////            String path = "entry:instrument:detector_"+detStr+":polar_angle" 
     3967//       
     3968//              Make/O/D/N=1 wTmpWrite 
     3969//      //      Make/O/R/N=1 wTmpWrite 
     3970//              String groupName = "/entry/instrument/detector_"+detStr  
     3971//              String varName = "polar_angle" 
     3972//              wTmpWrite[0] = val 
     3973// 
     3974//              variable err 
     3975//              err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3976//              if(err) 
     3977//                      Print "HDF write err = ",err 
     3978//              endif 
     3979//              // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3980////            err = V_KillNamedDataFolder(fname) 
     3981////            if(err) 
     3982////                    Print "DataFolder kill err = ",err 
     3983////            endif 
     3984//              return(err) 
     3985//      else 
     3986//              return(0) 
     3987//      endif 
     3988//End 
     3989 
     3990//// only defined for the "B" detector, and only to satisfy NXsas 
     3991//Function V_writeDet_rotational_angle(fname,detStr,val) 
     3992//      String fname,detStr 
     3993//      Variable val 
     3994// 
     3995//      if(cmpstr(detStr,"B") == 0) 
     3996////            String path = "entry:instrument:detector_"+detStr+":rotational_angle" 
     3997//       
     3998//              Make/O/D/N=1 wTmpWrite 
     3999//      //      Make/O/R/N=1 wTmpWrite 
     4000//              String groupName = "/entry/instrument/detector_"+detStr  
     4001//              String varName = "rotational_angle" 
     4002//              wTmpWrite[0] = val 
     4003// 
     4004//              variable err 
     4005//              err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     4006//              if(err) 
     4007//                      Print "HDF write err = ",err 
     4008//              endif 
     4009//              // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4010////            err = V_KillNamedDataFolder(fname) 
     4011////            if(err) 
     4012////                    Print "DataFolder kill err = ",err 
     4013////            endif 
     4014//              return(err) 
     4015//      else 
     4016//              return(0) 
     4017//      endif 
     4018//End 
     4019 
     4020Function V_writeDetSettings(fname,detStr,str) 
     4021        String fname,detStr,str 
     4022 
     4023//      String path = "entry:instrument:detector_"+detStr+":settings" 
     4024 
     4025        Make/O/T/N=1 tmpTW 
     4026        String groupName = "/entry/instrument/detector_"+detStr //       
     4027        String varName = "settings" 
     4028        tmpTW[0] = str // 
     4029 
     4030        variable err 
     4031        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     4032        if(err) 
     4033                Print "HDF write err = ",err 
     4034        endif 
     4035         
     4036        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4037//      err = V_KillNamedDataFolder(fname) 
     4038//      if(err) 
     4039//              Print "DataFolder kill err = ",err 
     4040//      endif 
     4041                 
     4042        return(err) 
     4043End 
     4044 
     4045//// really has no meaning at all  
     4046//Function V_writeDet_size(fname,detStr,val) 
     4047//      String fname,detStr 
     4048//      Variable val 
     4049// 
     4050////    String path = "entry:instrument:detector_"+detStr+":size" 
     4051//       
     4052//      Make/O/D/N=1 wTmpWrite 
     4053////    Make/O/R/N=1 wTmpWrite 
     4054//      String groupName = "/entry/instrument/detector_"+detStr  
     4055//      String varName = "size" 
     4056//      wTmpWrite[0] = val 
     4057// 
     4058//      variable err 
     4059//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     4060//      if(err) 
     4061//              Print "HDF write err = ",err 
     4062//      endif 
     4063//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4064////    err = V_KillNamedDataFolder(fname) 
     4065////    if(err) 
     4066////            Print "DataFolder kill err = ",err 
     4067////    endif 
     4068//      return(err) 
     4069//End 
     4070 
     4071Function V_writeDetType(fname,detStr,str) 
     4072        String fname,detStr,str 
     4073 
     4074//      String path = "entry:instrument:detector_"+detStr+":type" 
     4075 
     4076        Make/O/T/N=1 tmpTW 
     4077        String groupName = "/entry/instrument/detector_"+detStr //       
     4078        String varName = "type" 
     4079        tmpTW[0] = str // 
     4080 
     4081        variable err 
     4082        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     4083        if(err) 
     4084                Print "HDF write err = ",err 
     4085        endif 
     4086         
     4087        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4088//      err = V_KillNamedDataFolder(fname) 
     4089//      if(err) 
     4090//              Print "DataFolder kill err = ",err 
     4091//      endif 
     4092                 
     4093        return(err) 
     4094End 
     4095 
     4096Function V_writeDet_x_pixel_size(fname,detStr,val) 
     4097        String fname,detStr 
     4098        Variable val 
     4099 
     4100//      String path = "entry:instrument:detector_"+detStr+":x_pixel_size" 
     4101         
     4102        Make/O/D/N=1 wTmpWrite 
     4103//      Make/O/R/N=1 wTmpWrite 
     4104        String groupName = "/entry/instrument/detector_"+detStr  
     4105        String varName = "x_pixel_size" 
     4106        wTmpWrite[0] = val 
     4107 
     4108        variable err 
     4109        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     4110        if(err) 
     4111                Print "HDF write err = ",err 
     4112        endif 
     4113        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4114//      err = V_KillNamedDataFolder(fname) 
     4115//      if(err) 
     4116//              Print "DataFolder kill err = ",err 
     4117//      endif 
     4118        return(err) 
     4119End 
     4120 
     4121Function V_writeDet_y_pixel_size(fname,detStr,val) 
     4122        String fname,detStr 
     4123        Variable val 
     4124 
     4125//      String path = "entry:instrument:detector_"+detStr+":y_pixel_size" 
     4126         
     4127        Make/O/D/N=1 wTmpWrite 
     4128//      Make/O/R/N=1 wTmpWrite 
     4129        String groupName = "/entry/instrument/detector_"+detStr  
     4130        String varName = "y_pixel_size" 
     4131        wTmpWrite[0] = val 
     4132 
     4133        variable err 
     4134        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     4135        if(err) 
     4136                Print "HDF write err = ",err 
     4137        endif 
     4138        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4139//      err = V_KillNamedDataFolder(fname) 
     4140//      if(err) 
     4141//              Print "DataFolder kill err = ",err 
     4142//      endif 
     4143        return(err) 
     4144End 
     4145 
     4146/////////                       detector_FB (data folder) + ALL other PANEL DETECTORS 
     4147 
     4148// integer value 
     4149Function V_writeDet_numberOfTubes(fname,detStr,val) 
     4150        String fname,detStr 
     4151        Variable val 
     4152 
     4153//      String path = "entry:instrument:detector_"+detStr+":number_of_tubes" 
     4154        if(cmpstr(detStr,"B") == 0) 
     4155                return(0) 
     4156        else 
     4157         
     4158                Make/O/I/N=1 wTmpWrite 
     4159        //      Make/O/R/N=1 wTmpWrite 
     4160                String groupName = "/entry/instrument/detector_"+detStr  
     4161                String varName = "number_of_tubes" 
    31354162                wTmpWrite[0] = val 
    31364163 
     
    31464173//              endif 
    31474174                return(err) 
     4175        endif 
     4176End 
     4177 
     4178// TODO -- be clear on how this is defined. Separation as defined from what point? Units? 
     4179Function V_writeDetPanelSeparation(fname,detStr,val) 
     4180        String fname,detStr 
     4181        Variable val 
     4182 
     4183//      String path = "entry:instrument:detector_"+detStr+":separation" 
     4184        if(cmpstr(detStr,"B") == 0) 
     4185                return(0) 
    31484186        else 
    3149                 return(0) 
    3150         endif 
    3151 End 
    3152  
    3153 Function V_writeDet_beam_center_x(fname,detStr,val) 
    3154         String fname,detStr 
    3155         Variable val 
    3156  
    3157 //      String path = "entry:instrument:detector_"+detStr+":beam_center_x" 
    3158          
    3159         Make/O/D/N=1 wTmpWrite 
    3160 //      Make/O/R/N=1 wTmpWrite 
    3161         String groupName = "/entry/instrument/detector_"+detStr  
    3162         String varName = "beam_center_x" 
    3163         wTmpWrite[0] = val 
    3164  
    3165         variable err 
    3166         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3167         if(err) 
    3168                 Print "HDF write err = ",err 
    3169         endif 
    3170         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3171 //      err = V_KillNamedDataFolder(fname) 
    3172 //      if(err) 
    3173 //              Print "DataFolder kill err = ",err 
    3174 //      endif 
    3175         return(err) 
    3176 End 
    3177  
    3178 // fname is a local WORK folder 
    3179 Function V_putDet_beam_center_x(fname,detStr,val) 
    3180         String fname,detStr 
    3181         Variable val 
    3182  
    3183 //root:Packages:NIST:VSANS:RAW:entry:entry:instrument:detector_FB:beam_center_x 
    3184         String path = "root:Packages:NIST:VSANS:"+fname+":entry:" 
    3185         path += "entry:instrument:detector_"+detStr+":beam_center_x" 
    3186          
    3187         Wave/Z w = $path 
    3188         if(waveExists(w) == 0) 
    3189                 return(1) 
    3190         else 
    3191         w[0] = val 
    3192                 return(0) 
    3193         endif 
    3194  
    3195 End 
    3196  
    3197 Function V_writeDet_beam_center_y(fname,detStr,val) 
    3198         String fname,detStr 
    3199         Variable val 
    3200  
    3201 //      String path = "entry:instrument:detector_"+detStr+":beam_center_y" 
    3202          
    3203         Make/O/D/N=1 wTmpWrite 
    3204 //      Make/O/R/N=1 wTmpWrite 
    3205         String groupName = "/entry/instrument/detector_"+detStr  
    3206         String varName = "beam_center_y" 
    3207         wTmpWrite[0] = val 
    3208  
    3209         variable err 
    3210         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3211         if(err) 
    3212                 Print "HDF write err = ",err 
    3213         endif 
    3214         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3215 //      err = V_KillNamedDataFolder(fname) 
    3216 //      if(err) 
    3217 //              Print "DataFolder kill err = ",err 
    3218 //      endif 
    3219         return(err) 
    3220 End 
    3221  
    3222  
    3223 // fname is a local WORK folder 
    3224 Function V_putDet_beam_center_y(fname,detStr,val) 
    3225         String fname,detStr 
    3226         Variable val 
    3227  
    3228 //root:Packages:NIST:VSANS:RAW:entry:entry:instrument:detector_FB:beam_center_y 
    3229         String path = "root:Packages:NIST:VSANS:"+fname+":entry:" 
    3230         path += "entry:instrument:detector_"+detStr+":beam_center_y" 
    3231          
    3232         Wave/Z w = $path 
    3233         if(waveExists(w) == 0) 
    3234                 return(1) 
    3235         else 
    3236         w[0] = val 
    3237                 return(0) 
    3238         endif 
    3239  
    3240 End 
    3241  
    3242  
    3243 // TODO -- write this function to return a WAVE with the data 
    3244 // either as a wave reference, or as an input parameter 
    3245 Function V_writeDetectorData(fname,detStr,inW) 
    3246         String fname,detStr 
    3247         Wave inW 
    3248  
    3249 //      String path = "entry:instrument:detector_"+detStr+":data" 
    3250          
    3251         Duplicate/O inW wTmpWrite        
    3252 // then use redimension as needed to cast the wave to write to the specified type 
    3253 // see WaveType for the proper codes  
    3254 //      Redimension/T=() wTmpWrite 
    3255 // -- May also need to check the dimension(s) before writing (don't trust the input) 
    3256         String groupName = "/entry/instrument/detector_"+detStr  
    3257         String varName = "data" 
    3258  
    3259         variable err 
    3260         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3261         if(err) 
    3262                 Print "HDF write err = ",err 
    3263         endif 
    3264         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3265 //      err = V_KillNamedDataFolder(fname) 
    3266 //      if(err) 
    3267 //              Print "DataFolder kill err = ",err 
    3268 //      endif 
    3269         return(err) 
    3270 End 
    3271  
    3272  
    3273 // TODO -- write this function to return a WAVE with the data 
    3274 // either as a wave reference, or as an input parameter 
    3275 // ALSO -- the "B" deadtime will be a single value (probably) 
    3276 //  but the tube banks will be 1D arrays of values, one per tube 
    3277 Function V_writeDetector_deadtime(fname,detStr,inW) 
    3278         String fname,detStr 
    3279         Wave inW 
    3280  
    3281 //      String path = "entry:instrument:detector_"+detStr+":dead_time" 
    3282          
    3283         Duplicate/O inW wTmpWrite        
    3284 // then use redimension as needed to cast the wave to write to the specified type 
    3285 // see WaveType for the proper codes  
    3286 //      Redimension/T=() wTmpWrite 
    3287 // -- May also need to check the dimension(s) before writing (don't trust the input) 
    3288         String groupName = "/entry/instrument/detector_"+detStr  
    3289         String varName = "dead_time" 
    3290  
    3291         variable err 
    3292         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3293         if(err) 
    3294                 Print "HDF write err = ",err 
    3295         endif 
    3296         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3297 //      err = V_KillNamedDataFolder(fname) 
    3298 //      if(err) 
    3299 //              Print "DataFolder kill err = ",err 
    3300 //      endif 
    3301         return(err) 
    3302 End 
    3303  
    3304  
    3305 Function V_writeDetDescription(fname,detStr,str) 
    3306         String fname,detStr,str 
    3307  
    3308 //      String path = "entry:instrument:detector_"+detStr+":description" 
    3309  
    3310         Make/O/T/N=1 tmpTW 
    3311         String groupName = "/entry/instrument/detector_"+detStr //       
    3312         String varName = "description" 
    3313         tmpTW[0] = str // 
    3314  
    3315         variable err 
    3316         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    3317         if(err) 
    3318                 Print "HDF write err = ",err 
    3319         endif 
    3320          
    3321         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3322 //      err = V_KillNamedDataFolder(fname) 
    3323 //      if(err) 
    3324 //              Print "DataFolder kill err = ",err 
    3325 //      endif 
    3326                  
    3327         return(err) 
    3328 End 
    3329  
    3330 Function V_writeDet_distance(fname,detStr,val) 
    3331         String fname,detStr 
    3332         variable val 
    3333  
    3334 //      String path = "entry:instrument:detector_"+detStr+":distance" 
    3335          
    3336         Make/O/D/N=1 wTmpWrite 
    3337 //      Make/O/R/N=1 wTmpWrite 
    3338         String groupName = "/entry/instrument/detector_"+detStr  
    3339         String varName = "distance" 
    3340         wTmpWrite[0] = val 
    3341  
    3342         variable err 
    3343         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3344         if(err) 
    3345                 Print "HDF write err = ",err 
    3346         endif 
    3347         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3348 //      err = V_KillNamedDataFolder(fname) 
    3349 //      if(err) 
    3350 //              Print "DataFolder kill err = ",err 
    3351 //      endif 
    3352         return(err) 
    3353 End 
    3354  
    3355 // only defined for the "B" detector, and only to satisfy NXsas 
    3356 Function V_writeDet_equatorial_angle(fname,detStr,val) 
    3357         String fname,detStr 
    3358         variable val 
    3359  
    3360         if(cmpstr(detStr,"B") == 0) 
    3361 //              String path = "entry:instrument:detector_"+detStr+":equatorial_angle" 
    33624187         
    33634188                Make/O/D/N=1 wTmpWrite 
    33644189        //      Make/O/R/N=1 wTmpWrite 
    33654190                String groupName = "/entry/instrument/detector_"+detStr  
    3366                 String varName = "equatorial_angle" 
     4191                String varName = "separation" 
    33674192                wTmpWrite[0] = val 
    33684193 
     
    33784203//              endif 
    33794204                return(err) 
     4205        endif 
     4206End 
     4207 
     4208// TODO -- write this function to return a WAVE with the data 
     4209// either as a wave reference, or as an input parameter 
     4210Function V_writeDetTube_spatialCalib(fname,detStr,inW) 
     4211        String fname,detStr 
     4212        Wave inW 
     4213 
     4214//      String path = "entry:instrument:detector_"+detStr+":spatial_calibration" 
     4215 
     4216        if(cmpstr(detStr,"B") == 0) 
     4217                return(0) 
    33804218        else 
    3381                 return(0) 
    3382         endif 
    3383 End 
    3384  
    3385 Function V_writeDetEventFileName(fname,detStr,str) 
    3386         String fname,detStr,str 
    3387  
    3388 //      String path = "entry:instrument:detector_"+detStr+":event_file_name" 
    3389  
    3390         Make/O/T/N=1 tmpTW 
    3391         String groupName = "/entry/instrument/detector_"+detStr //       
    3392         String varName = "event_file_name" 
    3393         tmpTW[0] = str // 
    3394  
    3395         variable err 
    3396         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    3397         if(err) 
    3398                 Print "HDF write err = ",err 
    3399         endif 
    3400          
    3401         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3402 //      err = V_KillNamedDataFolder(fname) 
    3403 //      if(err) 
    3404 //              Print "DataFolder kill err = ",err 
    3405 //      endif 
    3406                  
    3407         return(err) 
    3408 End 
    3409  
    3410 Function V_writeDet_IntegratedCount(fname,detStr,val) 
    3411         String fname,detStr 
    3412         Variable val 
    3413  
    3414 //      String path = "entry:instrument:detector_"+detStr+":integrated_count" 
    3415          
    3416         Make/O/D/N=1 wTmpWrite 
    3417 //      Make/O/R/N=1 wTmpWrite 
    3418         String groupName = "/entry/instrument/detector_"+detStr  
    3419         String varName = "integrated_count" 
    3420         wTmpWrite[0] = val 
    3421  
    3422         variable err 
    3423         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3424         if(err) 
    3425                 Print "HDF write err = ",err 
    3426         endif 
    3427         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3428 //      err = V_KillNamedDataFolder(fname) 
    3429 //      if(err) 
    3430 //              Print "DataFolder kill err = ",err 
    3431 //      endif 
    3432         return(err) 
    3433 End 
    3434  
    3435 Function V_writeDet_LateralOffset(fname,detStr,val) 
    3436         String fname,detStr 
    3437         Variable val 
    3438  
    3439 //      String path = "entry:instrument:detector_"+detStr+":lateral_offset" 
    3440          
    3441         Make/O/D/N=1 wTmpWrite 
    3442 //      Make/O/R/N=1 wTmpWrite 
    3443         String groupName = "/entry/instrument/detector_"+detStr  
    3444         String varName = "lateral_offset" 
    3445         wTmpWrite[0] = val 
    3446  
    3447         variable err 
    3448         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3449         if(err) 
    3450                 Print "HDF write err = ",err 
    3451         endif 
    3452         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3453 //      err = V_KillNamedDataFolder(fname) 
    3454 //      if(err) 
    3455 //              Print "DataFolder kill err = ",err 
    3456 //      endif 
    3457         return(err) 
    3458 End 
    3459  
    3460 Function V_writeDet_VerticalOffset(fname,detStr,val) 
    3461         String fname,detStr 
    3462         Variable val 
    3463  
    3464 //      String path = "entry:instrument:detector_"+detStr+":vertical_offset" 
    3465          
    3466         Make/O/D/N=1 wTmpWrite 
    3467 //      Make/O/R/N=1 wTmpWrite 
    3468         String groupName = "/entry/instrument/detector_"+detStr  
    3469         String varName = "vertical_offset" 
    3470         wTmpWrite[0] = val 
    3471  
    3472         variable err 
    3473         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3474         if(err) 
    3475                 Print "HDF write err = ",err 
    3476         endif 
    3477         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3478 //      err = V_KillNamedDataFolder(fname) 
    3479 //      if(err) 
    3480 //              Print "DataFolder kill err = ",err 
    3481 //      endif 
    3482         return(err) 
    3483 End 
    3484  
    3485 // only defined for the "B" detector, and only to satisfy NXsas 
    3486 Function V_writeDet_polar_angle(fname,detStr,val) 
    3487         String fname,detStr 
    3488         Variable val 
    3489  
    3490         if(cmpstr(detStr,"B") == 0) 
    3491 //              String path = "entry:instrument:detector_"+detStr+":polar_angle" 
    3492          
    3493                 Make/O/D/N=1 wTmpWrite 
    3494         //      Make/O/R/N=1 wTmpWrite 
     4219                Duplicate/O inW wTmpWrite        
     4220        // then use redimension as needed to cast the wave to write to the specified type 
     4221        // see WaveType for the proper codes  
     4222        //      Redimension/T=() wTmpWrite 
     4223        // -- May also need to check the dimension(s) before writing (don't trust the input) 
    34954224                String groupName = "/entry/instrument/detector_"+detStr  
    3496                 String varName = "polar_angle" 
    3497                 wTmpWrite[0] = val 
     4225                String varName = "spatial_calibration" 
    34984226 
    34994227                variable err 
     
    35084236//              endif 
    35094237                return(err) 
     4238        endif 
     4239End 
     4240 
     4241//// TODO -- be clear on how this is defined. 
     4242//Function V_writeDet_tubeIndex(fname,detStr,val) 
     4243//      String fname,detStr 
     4244//      Variable val 
     4245// 
     4246////    String path = "entry:instrument:detector_"+detStr+":tube_index" 
     4247//      if(cmpstr(detStr,"B") == 0) 
     4248//              return(0) 
     4249//      else 
     4250//       
     4251//              Make/O/D/N=1 wTmpWrite 
     4252//      //      Make/O/R/N=1 wTmpWrite 
     4253//              String groupName = "/entry/instrument/detector_"+detStr  
     4254//              String varName = "tube_index" 
     4255//              wTmpWrite[0] = val 
     4256// 
     4257//              variable err 
     4258//              err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     4259//              if(err) 
     4260//                      Print "HDF write err = ",err 
     4261//              endif 
     4262//              // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4263////            err = V_KillNamedDataFolder(fname) 
     4264////            if(err) 
     4265////                    Print "DataFolder kill err = ",err 
     4266////            endif 
     4267//              return(err) 
     4268//      endif 
     4269//End 
     4270 
     4271Function V_writeDet_tubeOrientation(fname,detStr,str) 
     4272        String fname,detStr,str 
     4273 
     4274//      String path = "entry:instrument:detector_"+detStr+":tube_orientation" 
     4275 
     4276        if(cmpstr(detStr,"B") == 0) 
     4277                return(0) 
    35104278        else 
     4279                Make/O/T/N=1 tmpTW 
     4280                String groupName = "/entry/instrument/detector_"+detStr //       
     4281                String varName = "tube_orientation" 
     4282                tmpTW[0] = str // 
     4283 
     4284                variable err 
     4285                err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     4286                if(err) 
     4287                        Print "HDF write err = ",err 
     4288                endif 
     4289         
     4290                // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4291//              err = V_KillNamedDataFolder(fname) 
     4292//              if(err) 
     4293//                      Print "DataFolder kill err = ",err 
     4294//              endif 
     4295                 
     4296                return(err) 
     4297 
     4298        endif 
     4299End 
     4300 
     4301// TODO -- be clear on how this is defined. Units? 
     4302Function V_writeDet_tubeWidth(fname,detStr,val) 
     4303        String fname,detStr 
     4304        Variable val 
     4305 
     4306//      String path = "entry:instrument:detector_"+detStr+":tube_width" 
     4307        if(cmpstr(detStr,"B") == 0) 
    35114308                return(0) 
    3512         endif 
    3513 End 
    3514  
    3515 // only defined for the "B" detector, and only to satisfy NXsas 
    3516 Function V_writeDet_rotational_angle(fname,detStr,val) 
    3517         String fname,detStr 
    3518         Variable val 
    3519  
    3520         if(cmpstr(detStr,"B") == 0) 
    3521 //              String path = "entry:instrument:detector_"+detStr+":rotational_angle" 
     4309        else 
    35224310         
    35234311                Make/O/D/N=1 wTmpWrite 
    35244312        //      Make/O/R/N=1 wTmpWrite 
    35254313                String groupName = "/entry/instrument/detector_"+detStr  
    3526                 String varName = "rotational_angle" 
     4314                String varName = "tube_width" 
    35274315                wTmpWrite[0] = val 
    35284316 
     
    35384326//              endif 
    35394327                return(err) 
    3540         else 
    3541                 return(0) 
    3542         endif 
    3543 End 
    3544  
    3545 Function V_writeDetSettings(fname,detStr,str) 
    3546         String fname,detStr,str 
    3547  
    3548 //      String path = "entry:instrument:detector_"+detStr+":settings" 
    3549  
    3550         Make/O/T/N=1 tmpTW 
    3551         String groupName = "/entry/instrument/detector_"+detStr //       
    3552         String varName = "settings" 
    3553         tmpTW[0] = str // 
    3554  
    3555         variable err 
    3556         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    3557         if(err) 
    3558                 Print "HDF write err = ",err 
    3559         endif 
    3560          
    3561         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3562 //      err = V_KillNamedDataFolder(fname) 
    3563 //      if(err) 
    3564 //              Print "DataFolder kill err = ",err 
    3565 //      endif 
    3566                  
    3567         return(err) 
    3568 End 
    3569  
    3570 // really has no meaning at all  
    3571 Function V_writeDet_size(fname,detStr,val) 
    3572         String fname,detStr 
    3573         Variable val 
    3574  
    3575 //      String path = "entry:instrument:detector_"+detStr+":size" 
    3576          
    3577         Make/O/D/N=1 wTmpWrite 
    3578 //      Make/O/R/N=1 wTmpWrite 
    3579         String groupName = "/entry/instrument/detector_"+detStr  
    3580         String varName = "size" 
    3581         wTmpWrite[0] = val 
    3582  
    3583         variable err 
    3584         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3585         if(err) 
    3586                 Print "HDF write err = ",err 
    3587         endif 
    3588         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3589 //      err = V_KillNamedDataFolder(fname) 
    3590 //      if(err) 
    3591 //              Print "DataFolder kill err = ",err 
    3592 //      endif 
    3593         return(err) 
    3594 End 
    3595  
    3596 Function V_writeDetType(fname,detStr,str) 
    3597         String fname,detStr,str 
    3598  
    3599 //      String path = "entry:instrument:detector_"+detStr+":type" 
    3600  
    3601         Make/O/T/N=1 tmpTW 
    3602         String groupName = "/entry/instrument/detector_"+detStr //       
    3603         String varName = "type" 
    3604         tmpTW[0] = str // 
    3605  
    3606         variable err 
    3607         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    3608         if(err) 
    3609                 Print "HDF write err = ",err 
    3610         endif 
    3611          
    3612         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3613 //      err = V_KillNamedDataFolder(fname) 
    3614 //      if(err) 
    3615 //              Print "DataFolder kill err = ",err 
    3616 //      endif 
    3617                  
    3618         return(err) 
    3619 End 
    3620  
    3621 Function V_writeDet_x_pixel_size(fname,detStr,val) 
    3622         String fname,detStr 
    3623         Variable val 
    3624  
    3625 //      String path = "entry:instrument:detector_"+detStr+":x_pixel_size" 
    3626          
    3627         Make/O/D/N=1 wTmpWrite 
    3628 //      Make/O/R/N=1 wTmpWrite 
    3629         String groupName = "/entry/instrument/detector_"+detStr  
    3630         String varName = "x_pixel_size" 
    3631         wTmpWrite[0] = val 
    3632  
    3633         variable err 
    3634         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3635         if(err) 
    3636                 Print "HDF write err = ",err 
    3637         endif 
    3638         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3639 //      err = V_KillNamedDataFolder(fname) 
    3640 //      if(err) 
    3641 //              Print "DataFolder kill err = ",err 
    3642 //      endif 
    3643         return(err) 
    3644 End 
    3645  
    3646 Function V_writeDet_y_pixel_size(fname,detStr,val) 
    3647         String fname,detStr 
    3648         Variable val 
    3649  
    3650 //      String path = "entry:instrument:detector_"+detStr+":y_pixel_size" 
    3651          
    3652         Make/O/D/N=1 wTmpWrite 
    3653 //      Make/O/R/N=1 wTmpWrite 
    3654         String groupName = "/entry/instrument/detector_"+detStr  
    3655         String varName = "y_pixel_size" 
    3656         wTmpWrite[0] = val 
    3657  
    3658         variable err 
    3659         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3660         if(err) 
    3661                 Print "HDF write err = ",err 
    3662         endif 
    3663         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3664 //      err = V_KillNamedDataFolder(fname) 
    3665 //      if(err) 
    3666 //              Print "DataFolder kill err = ",err 
    3667 //      endif 
    3668         return(err) 
    3669 End 
    3670  
    3671 /////////                       detector_FB (data folder) + ALL other PANEL DETECTORS 
    3672  
    3673 Function V_writeDet_numberOfTubes(fname,detStr,val) 
    3674         String fname,detStr 
    3675         Variable val 
    3676  
    3677 //      String path = "entry:instrument:detector_"+detStr+":number_of_tubes" 
    3678         if(cmpstr(detStr,"B") == 0) 
    3679                 return(0) 
    3680         else 
    3681          
    3682                 Make/O/D/N=1 wTmpWrite 
    3683         //      Make/O/R/N=1 wTmpWrite 
    3684                 String groupName = "/entry/instrument/detector_"+detStr  
    3685                 String varName = "number_of_tubes" 
    3686                 wTmpWrite[0] = val 
    3687  
    3688                 variable err 
    3689                 err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3690                 if(err) 
    3691                         Print "HDF write err = ",err 
    3692                 endif 
    3693                 // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3694 //              err = V_KillNamedDataFolder(fname) 
    3695 //              if(err) 
    3696 //                      Print "DataFolder kill err = ",err 
    3697 //              endif 
    3698                 return(err) 
    3699         endif 
    3700 End 
    3701  
    3702 // TODO -- be clear on how this is defined. Separation as defined from what point? Units? 
    3703 Function V_writeDetPanelSeparation(fname,detStr,val) 
    3704         String fname,detStr 
    3705         Variable val 
    3706  
    3707 //      String path = "entry:instrument:detector_"+detStr+":separation" 
    3708         if(cmpstr(detStr,"B") == 0) 
    3709                 return(0) 
    3710         else 
    3711          
    3712                 Make/O/D/N=1 wTmpWrite 
    3713         //      Make/O/R/N=1 wTmpWrite 
    3714                 String groupName = "/entry/instrument/detector_"+detStr  
    3715                 String varName = "separation" 
    3716                 wTmpWrite[0] = val 
    3717  
    3718                 variable err 
    3719                 err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3720                 if(err) 
    3721                         Print "HDF write err = ",err 
    3722                 endif 
    3723                 // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3724 //              err = V_KillNamedDataFolder(fname) 
    3725 //              if(err) 
    3726 //                      Print "DataFolder kill err = ",err 
    3727 //              endif 
    3728                 return(err) 
    3729         endif 
    3730 End 
    3731  
    3732 // TODO -- write this function to return a WAVE with the data 
    3733 // either as a wave reference, or as an input parameter 
    3734 Function V_writeDetTube_spatialCalib(fname,detStr,inW) 
    3735         String fname,detStr 
    3736         Wave inW 
    3737  
    3738 //      String path = "entry:instrument:detector_"+detStr+":spatial_calibration" 
    3739  
    3740         if(cmpstr(detStr,"B") == 0) 
    3741                 return(0) 
    3742         else 
    3743                 Duplicate/O inW wTmpWrite        
    3744         // then use redimension as needed to cast the wave to write to the specified type 
    3745         // see WaveType for the proper codes  
    3746         //      Redimension/T=() wTmpWrite 
    3747         // -- May also need to check the dimension(s) before writing (don't trust the input) 
    3748                 String groupName = "/entry/instrument/detector_"+detStr  
    3749                 String varName = "spatial_calibration" 
    3750  
    3751                 variable err 
    3752                 err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3753                 if(err) 
    3754                         Print "HDF write err = ",err 
    3755                 endif 
    3756                 // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3757 //              err = V_KillNamedDataFolder(fname) 
    3758 //              if(err) 
    3759 //                      Print "DataFolder kill err = ",err 
    3760 //              endif 
    3761                 return(err) 
    3762         endif 
    3763 End 
    3764  
    3765 // TODO -- be clear on how this is defined. 
    3766 Function V_writeDet_tubeIndex(fname,detStr,val) 
    3767         String fname,detStr 
    3768         Variable val 
    3769  
    3770 //      String path = "entry:instrument:detector_"+detStr+":tube_index" 
    3771         if(cmpstr(detStr,"B") == 0) 
    3772                 return(0) 
    3773         else 
    3774          
    3775                 Make/O/D/N=1 wTmpWrite 
    3776         //      Make/O/R/N=1 wTmpWrite 
    3777                 String groupName = "/entry/instrument/detector_"+detStr  
    3778                 String varName = "tube_index" 
    3779                 wTmpWrite[0] = val 
    3780  
    3781                 variable err 
    3782                 err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3783                 if(err) 
    3784                         Print "HDF write err = ",err 
    3785                 endif 
    3786                 // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3787 //              err = V_KillNamedDataFolder(fname) 
    3788 //              if(err) 
    3789 //                      Print "DataFolder kill err = ",err 
    3790 //              endif 
    3791                 return(err) 
    3792         endif 
    3793 End 
    3794  
    3795 Function V_writeDet_tubeOrientation(fname,detStr,str) 
    3796         String fname,detStr,str 
    3797  
    3798 //      String path = "entry:instrument:detector_"+detStr+":tube_orientation" 
    3799  
    3800         if(cmpstr(detStr,"B") == 0) 
    3801                 return(0) 
    3802         else 
    3803                 Make/O/T/N=1 tmpTW 
    3804                 String groupName = "/entry/instrument/detector_"+detStr //       
    3805                 String varName = "tube_orientation" 
    3806                 tmpTW[0] = str // 
    3807  
    3808                 variable err 
    3809                 err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    3810                 if(err) 
    3811                         Print "HDF write err = ",err 
    3812                 endif 
    3813          
    3814                 // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3815 //              err = V_KillNamedDataFolder(fname) 
    3816 //              if(err) 
    3817 //                      Print "DataFolder kill err = ",err 
    3818 //              endif 
    3819                  
    3820                 return(err) 
    3821  
    3822         endif 
    3823 End 
    3824  
    3825 // TODO -- be clear on how this is defined. Units? 
    3826 Function V_writeDet_tubeWidth(fname,detStr,val) 
    3827         String fname,detStr 
    3828         Variable val 
    3829  
    3830 //      String path = "entry:instrument:detector_"+detStr+":tube_width" 
    3831         if(cmpstr(detStr,"B") == 0) 
    3832                 return(0) 
    3833         else 
    3834          
    3835                 Make/O/D/N=1 wTmpWrite 
    3836         //      Make/O/R/N=1 wTmpWrite 
    3837                 String groupName = "/entry/instrument/detector_"+detStr  
    3838                 String varName = "tube_width" 
    3839                 wTmpWrite[0] = val 
    3840  
    3841                 variable err 
    3842                 err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    3843                 if(err) 
    3844                         Print "HDF write err = ",err 
    3845                 endif 
    3846                 // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    3847 //              err = V_KillNamedDataFolder(fname) 
    3848 //              if(err) 
    3849 //                      Print "DataFolder kill err = ",err 
    3850 //              endif 
    3851                 return(err) 
    38524328        endif 
    38534329End 
     
    39834459End 
    39844460 
     4461// integer value 
    39854462Function V_writeNumber_of_Lenses(fname,val) 
    39864463        String fname 
     
    39894466//      String path = "entry:instrument:lenses:number_of_lenses" 
    39904467         
    3991         Make/O/D/N=1 wTmpWrite 
     4468        Make/O/I/N=1 wTmpWrite 
    39924469//      Make/O/R/N=1 wTmpWrite 
    39934470        String groupName = "/entry/instrument/lenses" 
     
    40084485End 
    40094486 
     4487// integer value 
    40104488Function V_writeNumber_of_prisms(fname,val) 
    40114489        String fname 
     
    40144492//      String path = "entry:instrument:lenses:number_of_prisms" 
    40154493         
    4016         Make/O/D/N=1 wTmpWrite 
     4494        Make/O/I/N=1 wTmpWrite 
    40174495//      Make/O/R/N=1 wTmpWrite 
    40184496        String groupName = "/entry/instrument/lenses" 
     
    41614639        return(err) 
    41624640End 
     4641 
    41634642//      shape (data folder) 
    41644643 
     
    41884667End 
    41894668 
    4190 // TODO -- this needs to return a WAVE, since the shape may be circle, or rectangle 
    4191 // and will need to return more than a single dimension 
    4192 // TODO -- be careful of the UNITS 
    4193 Function V_writeSampleAp_size(fname,inW) 
    4194         String fname 
    4195         Wave inW 
    4196  
    4197 //      String path = "entry:instrument:sample_aperture:shape:size" 
    4198  
    4199         Duplicate/O inW wTmpWrite        
    4200 // then use redimension as needed to cast the wave to write to the specified type 
    4201 // see WaveType for the proper codes  
    4202 //      Redimension/T=() wTmpWrite 
    4203 // -- May also need to check the dimension(s) before writing (don't trust the input) 
    4204         String groupName = "/entry/instrument/sample_aperture/shape"     
     4669Function V_writeSampleAp_height(fname,val) 
     4670        String fname 
     4671        Variable val 
     4672 
     4673//      String path = "entry:instrument:sample_aperture:distance" 
     4674         
     4675        Make/O/D/N=1 wTmpWrite 
     4676//      Make/O/R/N=1 wTmpWrite 
     4677        String groupName = "/entry/instrument/sample_aperture/shape" 
     4678        String varName = "height" 
     4679        wTmpWrite[0] = val 
     4680 
     4681        variable err 
     4682        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     4683        if(err) 
     4684                Print "HDF write err = ",err 
     4685        endif 
     4686        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4687//      err = V_KillNamedDataFolder(fname) 
     4688//      if(err) 
     4689//              Print "DataFolder kill err = ",err 
     4690//      endif 
     4691        return(err) 
     4692End 
     4693 
     4694Function V_writeSampleAp_size(fname,str) 
     4695        String fname,str 
     4696 
     4697//      String path = "entry:instrument:sample_aperture:shape:shape" 
     4698 
     4699        Make/O/T/N=1 tmpTW 
     4700        String groupName = "/entry/instrument/sample_aperture/shape" 
    42054701        String varName = "size" 
    4206  
    4207         variable err 
    4208         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    4209         if(err) 
    4210                 Print "HDF write err = ",err 
    4211         endif 
    4212         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    4213 //      err = V_KillNamedDataFolder(fname) 
    4214 //      if(err) 
    4215 //              Print "DataFolder kill err = ",err 
    4216 //      endif 
    4217         return(err) 
    4218 End      
    4219  
     4702        tmpTW[0] = str // 
     4703 
     4704        variable err 
     4705        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     4706        if(err) 
     4707                Print "HDF write err = ",err 
     4708        endif 
     4709         
     4710        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4711//      err = V_KillNamedDataFolder(fname) 
     4712//      if(err) 
     4713//              Print "DataFolder kill err = ",err 
     4714//      endif 
     4715                 
     4716        return(err) 
     4717End 
     4718 
     4719Function V_writeSampleAp_width(fname,val) 
     4720        String fname 
     4721        Variable val 
     4722 
     4723//      String path = "entry:instrument:sample_aperture:distance" 
     4724         
     4725        Make/O/D/N=1 wTmpWrite 
     4726//      Make/O/R/N=1 wTmpWrite 
     4727        String groupName = "/entry/instrument/sample_aperture/shape" 
     4728        String varName = "width" 
     4729        wTmpWrite[0] = val 
     4730 
     4731        variable err 
     4732        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     4733        if(err) 
     4734                Print "HDF write err = ",err 
     4735        endif 
     4736        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4737//      err = V_KillNamedDataFolder(fname) 
     4738//      if(err) 
     4739//              Print "DataFolder kill err = ",err 
     4740//      endif 
     4741        return(err) 
     4742End 
    42204743 
    42214744///////  sample_aperture_2 (data folder) 
     
    42704793        return(err) 
    42714794End 
     4795 
     4796 
    42724797//      shape (data folder) 
    42734798 
     
    42974822End 
    42984823 
    4299 // TODO -- this needs to return a WAVE, since the shape may be circle, or rectangle 
    4300 // and will need to return more than a single dimension 
    4301 // TODO -- be careful of the UNITS 
    4302 Function V_writeSampleAp2_size(fname,inW) 
    4303         String fname 
    4304         Wave inW 
    4305  
    4306 //      String path = "entry:instrument:sample_aperture_2:shape:size" 
    4307  
    4308         Duplicate/O inW wTmpWrite        
    4309 // then use redimension as needed to cast the wave to write to the specified type 
    4310 // see WaveType for the proper codes  
    4311 //      Redimension/T=() wTmpWrite 
    4312 // -- May also need to check the dimension(s) before writing (don't trust the input) 
    4313         String groupName = "/entry/instrument/sample_aperture_2/shape"   
     4824Function V_writeSampleAp2_height(fname,val) 
     4825        String fname 
     4826        Variable val 
     4827 
     4828//      String path = "entry:instrument:sample_aperture:distance" 
     4829         
     4830        Make/O/D/N=1 wTmpWrite 
     4831//      Make/O/R/N=1 wTmpWrite 
     4832        String groupName = "/entry/instrument/sample_aperture_2/shape" 
     4833        String varName = "height" 
     4834        wTmpWrite[0] = val 
     4835 
     4836        variable err 
     4837        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     4838        if(err) 
     4839                Print "HDF write err = ",err 
     4840        endif 
     4841        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4842//      err = V_KillNamedDataFolder(fname) 
     4843//      if(err) 
     4844//              Print "DataFolder kill err = ",err 
     4845//      endif 
     4846        return(err) 
     4847End 
     4848 
     4849Function V_writeSampleAp2_size(fname,val) 
     4850        String fname 
     4851        Variable val 
     4852 
     4853//      String path = "entry:instrument:sample_aperture:distance" 
     4854         
     4855        Make/O/D/N=1 wTmpWrite 
     4856//      Make/O/R/N=1 wTmpWrite 
     4857        String groupName = "/entry/instrument/sample_aperture_2/shape" 
    43144858        String varName = "size" 
    4315  
    4316         variable err 
    4317         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    4318         if(err) 
    4319                 Print "HDF write err = ",err 
    4320         endif 
    4321         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    4322 //      err = V_KillNamedDataFolder(fname) 
    4323 //      if(err) 
    4324 //              Print "DataFolder kill err = ",err 
    4325 //      endif 
    4326         return(err) 
    4327 End      
     4859        wTmpWrite[0] = val 
     4860 
     4861        variable err 
     4862        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     4863        if(err) 
     4864                Print "HDF write err = ",err 
     4865        endif 
     4866        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4867//      err = V_KillNamedDataFolder(fname) 
     4868//      if(err) 
     4869//              Print "DataFolder kill err = ",err 
     4870//      endif 
     4871        return(err) 
     4872End 
     4873 
     4874Function V_writeSampleAp2_width(fname,val) 
     4875        String fname 
     4876        Variable val 
     4877 
     4878//      String path = "entry:instrument:sample_aperture:distance" 
     4879         
     4880        Make/O/D/N=1 wTmpWrite 
     4881//      Make/O/R/N=1 wTmpWrite 
     4882        String groupName = "/entry/instrument/sample_aperture_2/shape" 
     4883        String varName = "width" 
     4884        wTmpWrite[0] = val 
     4885 
     4886        variable err 
     4887        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     4888        if(err) 
     4889                Print "HDF write err = ",err 
     4890        endif 
     4891        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     4892//      err = V_KillNamedDataFolder(fname) 
     4893//      if(err) 
     4894//              Print "DataFolder kill err = ",err 
     4895//      endif 
     4896        return(err) 
     4897End 
    43284898 
    43294899                 
     
    45665136End 
    45675137 
    4568 // TODO -- this needs to return a WAVE, since the shape may be circle, or rectangle 
    4569 // and will need to return more than a single dimension 
    4570 // TODO -- be careful of the UNITS 
    4571 Function V_writeSourceAp_size(fname,inW) 
    4572         String fname 
    4573         Wave inW 
    4574  
    4575 //      String path = "entry:instrument:source_aperture:shape:size" 
    4576  
    4577         Duplicate/O inW wTmpWrite        
    4578 // then use redimension as needed to cast the wave to write to the specified type 
    4579 // see WaveType for the proper codes  
    4580 //      Redimension/T=() wTmpWrite 
    4581 // -- May also need to check the dimension(s) before writing (don't trust the input) 
    4582         String groupName = "/entry/instrument/source_aperture/shape"     
     5138Function V_writeSourceAp_size(fname,str) 
     5139        String fname,str 
     5140 
     5141//      String path = "entry:instrument:source_aperture:shape:shape" 
     5142 
     5143        Make/O/T/N=1 tmpTW 
     5144        String groupName = "/entry/instrument/source_aperture/shape" 
    45835145        String varName = "size" 
    4584  
    4585         variable err 
    4586         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    4587         if(err) 
    4588                 Print "HDF write err = ",err 
    4589         endif 
    4590         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    4591 //      err = V_KillNamedDataFolder(fname) 
    4592 //      if(err) 
    4593 //              Print "DataFolder kill err = ",err 
    4594 //      endif 
    4595         return(err) 
    4596 End              
    4597  
    4598  
     5146        tmpTW[0] = str // 
     5147 
     5148        variable err 
     5149        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     5150        if(err) 
     5151                Print "HDF write err = ",err 
     5152        endif 
     5153         
     5154        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     5155//      err = V_KillNamedDataFolder(fname) 
     5156//      if(err) 
     5157//              Print "DataFolder kill err = ",err 
     5158//      endif 
     5159                 
     5160        return(err) 
     5161End 
     5162 
     5163Function V_writeSourceAp_height(fname,val) 
     5164        String fname 
     5165        Variable val 
     5166 
     5167//      String path = "entry:instrument:sample_aperture:distance" 
     5168         
     5169        Make/O/D/N=1 wTmpWrite 
     5170//      Make/O/R/N=1 wTmpWrite 
     5171        String groupName = "/entry/instrument/source_aperture/shape" 
     5172        String varName = "height" 
     5173        wTmpWrite[0] = val 
     5174 
     5175        variable err 
     5176        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     5177        if(err) 
     5178                Print "HDF write err = ",err 
     5179        endif 
     5180        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     5181//      err = V_KillNamedDataFolder(fname) 
     5182//      if(err) 
     5183//              Print "DataFolder kill err = ",err 
     5184//      endif 
     5185        return(err) 
     5186End 
     5187 
     5188Function V_writeSourceAp_width(fname,val) 
     5189        String fname 
     5190        Variable val 
     5191 
     5192//      String path = "entry:instrument:sample_aperture:distance" 
     5193         
     5194        Make/O/D/N=1 wTmpWrite 
     5195//      Make/O/R/N=1 wTmpWrite 
     5196        String groupName = "/entry/instrument/source_aperture/shape" 
     5197        String varName = "width" 
     5198        wTmpWrite[0] = val 
     5199 
     5200        variable err 
     5201        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     5202        if(err) 
     5203                Print "HDF write err = ",err 
     5204        endif 
     5205        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     5206//      err = V_KillNamedDataFolder(fname) 
     5207//      if(err) 
     5208//              Print "DataFolder kill err = ",err 
     5209//      endif 
     5210        return(err) 
     5211End 
    45995212 
    46005213 
     
    46045217 
    46055218//Sample position in changer 
    4606 // TODO -- in the NexusWriter, this ends up as a STRING -- which is wrong. it needs to be FP 
    4607 Function V_writeSamplePosition(fname,val) 
    4608         String fname 
    4609         Variable val 
    4610          
     5219Function V_writeSamplePosition(fname,str) 
     5220        String fname,str 
     5221 
    46115222//      String path = "entry:sample:changer_position"    
    4612          
    4613         Make/O/D/N=1 wTmpWrite 
    4614 //      Make/O/R/N=1 wTmpWrite 
     5223 
     5224        Make/O/T/N=1 tmpTW 
    46155225        String groupName = "/entry/sample" 
    46165226        String varName = "changer_position" 
    4617         wTmpWrite[0] = val 
    4618  
    4619         variable err 
    4620         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    4621         if(err) 
    4622                 Print "HDF write err = ",err 
    4623         endif 
    4624         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    4625 //      err = V_KillNamedDataFolder(fname) 
    4626 //      if(err) 
    4627 //              Print "DataFolder kill err = ",err 
    4628 //      endif 
    4629         return(err) 
    4630 end 
     5227        tmpTW[0] = str // 
     5228 
     5229        variable err 
     5230        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     5231        if(err) 
     5232                Print "HDF write err = ",err 
     5233        endif 
     5234         
     5235        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     5236//      err = V_KillNamedDataFolder(fname) 
     5237//      if(err) 
     5238//              Print "DataFolder kill err = ",err 
     5239//      endif 
     5240                 
     5241        return(err) 
     5242End 
     5243 
    46315244 
    46325245// sample label  
     
    46575270End 
    46585271 
     5272// for a z-stage?? 
     5273Function V_writeSample_elevation(fname,val) 
     5274        String fname 
     5275        Variable val 
     5276         
     5277//      String path = "entry:sample:elevation"   
     5278         
     5279        Make/O/D/N=1 wTmpWrite 
     5280//      Make/O/R/N=1 wTmpWrite 
     5281        String groupName = "/entry/sample" 
     5282        String varName = "elevation" 
     5283        wTmpWrite[0] = val 
     5284 
     5285        variable err 
     5286        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     5287        if(err) 
     5288                Print "HDF write err = ",err 
     5289        endif 
     5290        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     5291//      err = V_KillNamedDataFolder(fname) 
     5292//      if(err) 
     5293//              Print "DataFolder kill err = ",err 
     5294//      endif 
     5295        return(err) 
     5296end 
     5297 
    46595298//no meaning to this... 
    46605299Function V_writeSample_equatorial_ang(fname,val) 
     
    46855324// TODO -- do  I need to make sure that this is an integer? 
    46865325// group ID !!! very important for matching up files 
     5326// integer value 
    46875327Function V_writeSample_GroupID(fname,val) 
    46885328        String fname 
     
    46915331//      String path = "entry:sample:group_id"    
    46925332         
    4693         Make/O/D/N=1 wTmpWrite 
     5333        Make/O/I/N=1 wTmpWrite 
    46945334//      Make/O/R/N=1 wTmpWrite 
    46955335        String groupName = "/entry/sample" 
     
    47765416        String groupName = "/entry/sample" 
    47775417        String varName = "thickness" 
     5418        wTmpWrite[0] = val 
     5419 
     5420        variable err 
     5421        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     5422        if(err) 
     5423                Print "HDF write err = ",err 
     5424        endif 
     5425        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     5426//      err = V_KillNamedDataFolder(fname) 
     5427//      if(err) 
     5428//              Print "DataFolder kill err = ",err 
     5429//      endif 
     5430        return(err) 
     5431end 
     5432 
     5433//Sample Translation 
     5434Function V_writeSampleTranslation(fname,val) 
     5435        String fname 
     5436        Variable val 
     5437         
     5438//      String path = "entry:sample:translation"         
     5439         
     5440        Make/O/D/N=1 wTmpWrite 
     5441//      Make/O/R/N=1 wTmpWrite 
     5442        String groupName = "/entry/sample" 
     5443        String varName = "translation" 
    47785444        wTmpWrite[0] = val 
    47795445 
     
    53396005End 
    53406006 
     6007Function V_writeEmptyFileName(fname,str) 
     6008        String fname,str 
     6009 
     6010//      String path = "entry:reduction:empty_beam_file_name"     
     6011 
     6012        Make/O/T/N=1 tmpTW 
     6013        String groupName = "/entry/reduction" 
     6014        String varName = "empty_file_name" 
     6015        tmpTW[0] = str // 
     6016 
     6017        variable err 
     6018        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6019        if(err) 
     6020                Print "HDF write err = ",err 
     6021        endif 
     6022         
     6023        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6024//      err = V_KillNamedDataFolder(fname) 
     6025//      if(err) 
     6026//              Print "DataFolder kill err = ",err 
     6027//      endif 
     6028                 
     6029        return(err) 
     6030End 
     6031 
     6032Function V_writeMaskFileName(fname,str) 
     6033        String fname,str 
     6034 
     6035//      String path = "entry:reduction:empty_beam_file_name"     
     6036 
     6037        Make/O/T/N=1 tmpTW 
     6038        String groupName = "/entry/reduction" 
     6039        String varName = "mask_file_name" 
     6040        tmpTW[0] = str // 
     6041 
     6042        variable err 
     6043        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6044        if(err) 
     6045                Print "HDF write err = ",err 
     6046        endif 
     6047         
     6048        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6049//      err = V_KillNamedDataFolder(fname) 
     6050//      if(err) 
     6051//              Print "DataFolder kill err = ",err 
     6052//      endif 
     6053                 
     6054        return(err) 
     6055End 
     6056 
     6057Function V_writeBackgroundFileName(fname,str) 
     6058        String fname,str 
     6059 
     6060//      String path = "entry:reduction:empty_beam_file_name"     
     6061 
     6062        Make/O/T/N=1 tmpTW 
     6063        String groupName = "/entry/reduction" 
     6064        String varName = "background_file_name" 
     6065        tmpTW[0] = str // 
     6066 
     6067        variable err 
     6068        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6069        if(err) 
     6070                Print "HDF write err = ",err 
     6071        endif 
     6072         
     6073        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6074//      err = V_KillNamedDataFolder(fname) 
     6075//      if(err) 
     6076//              Print "DataFolder kill err = ",err 
     6077//      endif 
     6078                 
     6079        return(err) 
     6080End 
    53416081 
    53426082//whole detector transmission 
     
    54886228//                      thumbnail (data folder) 
    54896229 
    5490 //data (wave) "binary" 
    5491 // TODO -- this will need to be completely replaced with a function that can  
    5492 // read the binary image data. should be possible, but I don't know the details on either end... 
    5493 Function V_writeDataImage(fname,detStr,str) 
    5494         String fname,detStr,str 
    5495  
    5496 //      String path = "entry:data_"+detStr+":thumbnail:data"     
    5497  
    5498         Make/O/T/N=1 tmpTW 
    5499         String groupName = "/entry/data_"+detStr+"/thumbnail" 
    5500         String varName = "data" 
    5501         tmpTW[0] = str // 
    5502  
    5503         variable err 
    5504         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    5505         if(err) 
    5506                 Print "HDF write err = ",err 
    5507         endif 
    5508          
    5509         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    5510 //      err = V_KillNamedDataFolder(fname) 
    5511 //      if(err) 
    5512 //              Print "DataFolder kill err = ",err 
    5513 //      endif 
    5514                  
    5515         return(err) 
    5516 End 
    5517  
    5518 Function V_writeDataImageDescription(fname,detStr,str) 
    5519         String fname,detStr,str 
    5520  
    5521 //      String path = "entry:data_"+detStr+":thumbnail:description"      
    5522  
    5523         Make/O/T/N=1 tmpTW 
    5524         String groupName = "/entry/data_"+detStr+"/thumbnail" 
    5525         String varName = "description" 
    5526         tmpTW[0] = str // 
    5527  
    5528         variable err 
    5529         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    5530         if(err) 
    5531                 Print "HDF write err = ",err 
    5532         endif 
    5533          
    5534         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    5535 //      err = V_KillNamedDataFolder(fname) 
    5536 //      if(err) 
    5537 //              Print "DataFolder kill err = ",err 
    5538 //      endif 
    5539                  
    5540         return(err) 
    5541 End 
    5542                                                                  
    5543 Function V_writeDataImageType(fname,detStr,str) 
    5544         String fname,detStr,str 
    5545  
    5546 //      String path = "entry:data_"+detStr+":thumbnail:type"     
    5547  
    5548         Make/O/T/N=1 tmpTW 
    5549         String groupName = "/entry/data_"+detStr+"/thumbnail" 
    5550         String varName = "type" 
    5551         tmpTW[0] = str // 
    5552  
    5553         variable err 
    5554         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    5555         if(err) 
    5556                 Print "HDF write err = ",err 
    5557         endif 
    5558          
    5559         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    5560 //      err = V_KillNamedDataFolder(fname) 
    5561 //      if(err) 
    5562 //              Print "DataFolder kill err = ",err 
    5563 //      endif 
    5564                  
    5565         return(err) 
    5566 End 
    5567  
     6230////data (wave) "binary" 
     6231//// TODO -- this will need to be completely replaced with a function that can  
     6232//// read the binary image data. should be possible, but I don't know the details on either end... 
     6233//Function V_writeDataImage(fname,detStr,str) 
     6234//      String fname,detStr,str 
     6235// 
     6236////    String path = "entry:data_"+detStr+":thumbnail:data"     
     6237// 
     6238//      Make/O/T/N=1 tmpTW 
     6239//      String groupName = "/entry/data_"+detStr+"/thumbnail" 
     6240//      String varName = "data" 
     6241//      tmpTW[0] = str // 
     6242// 
     6243//      variable err 
     6244//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6245//      if(err) 
     6246//              Print "HDF write err = ",err 
     6247//      endif 
     6248//       
     6249//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6250////    err = V_KillNamedDataFolder(fname) 
     6251////    if(err) 
     6252////            Print "DataFolder kill err = ",err 
     6253////    endif 
     6254//               
     6255//      return(err) 
     6256//End 
     6257// 
     6258//Function V_writeDataImageDescription(fname,detStr,str) 
     6259//      String fname,detStr,str 
     6260// 
     6261////    String path = "entry:data_"+detStr+":thumbnail:description"      
     6262// 
     6263//      Make/O/T/N=1 tmpTW 
     6264//      String groupName = "/entry/data_"+detStr+"/thumbnail" 
     6265//      String varName = "description" 
     6266//      tmpTW[0] = str // 
     6267// 
     6268//      variable err 
     6269//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6270//      if(err) 
     6271//              Print "HDF write err = ",err 
     6272//      endif 
     6273//       
     6274//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6275////    err = V_KillNamedDataFolder(fname) 
     6276////    if(err) 
     6277////            Print "DataFolder kill err = ",err 
     6278////    endif 
     6279//               
     6280//      return(err) 
     6281//End 
     6282//                                                               
     6283//Function V_writeDataImageType(fname,detStr,str) 
     6284//      String fname,detStr,str 
     6285// 
     6286////    String path = "entry:data_"+detStr+":thumbnail:type"     
     6287// 
     6288//      Make/O/T/N=1 tmpTW 
     6289//      String groupName = "/entry/data_"+detStr+"/thumbnail" 
     6290//      String varName = "type" 
     6291//      tmpTW[0] = str // 
     6292// 
     6293//      variable err 
     6294//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6295//      if(err) 
     6296//              Print "HDF write err = ",err 
     6297//      endif 
     6298//       
     6299//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6300////    err = V_KillNamedDataFolder(fname) 
     6301////    if(err) 
     6302////            Print "DataFolder kill err = ",err 
     6303////    endif 
     6304//               
     6305//      return(err) 
     6306//End 
     6307// 
Note: See TracChangeset for help on using the changeset viewer.