Ignore:
Timestamp:
Jul 25, 2016 2:50:41 PM (6 years ago)
Author:
srkline
Message:

editing the read/write routines to include the latest additions to the json file definiton, including all of the additions to the polarization components. The file structure should be largely set at this point, with hopefully only minor changes as I shake out the bugs of working with the data.

File:
1 edited

Legend:

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

    r1000 r1005  
    569569 
    570570// list of user names 
    571 // TODO -- currently not written out to data file?? 
     571// DONE -- currently not written out to data file?? 
    572572Function V_writeUserNames(fname,str) 
    573573        String fname,str 
     
    602602// TODO -- for the control section, document each of the fields 
    603603// 
    604 Function V_writeCount_end(fname,val) 
    605         String fname 
    606         Variable val 
     604Function V_writeCount_end(fname,str) 
     605        String fname,str 
    607606         
    608607//      String path = "entry:control:count_end"  
    609          
    610         Make/O/D/N=1 wTmpWrite 
    611 //      Make/O/R/N=1 wTmpWrite 
    612         String groupName = "/entry/control"      
     608 
     609        Make/O/T/N=1 tmpTW 
     610        String groupName = "/entry/control"     //       
    613611        String varName = "count_end" 
    614         wTmpWrite[0] = val 
    615  
    616         variable err 
    617         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    618         if(err) 
    619                 Print "HDF write err = ",err 
    620         endif 
    621         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    622 //      err = V_KillNamedDataFolder(fname) 
    623 //      if(err) 
    624 //              Print "DataFolder kill err = ",err 
    625 //      endif 
    626         return(err) 
    627 end 
    628  
    629  
    630 Function V_writeCount_start(fname,val) 
    631         String fname 
    632         Variable val 
     612        tmpTW[0] = str // 
     613 
     614        variable err 
     615        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     616        if(err) 
     617                Print "HDF write err = ",err 
     618        endif 
     619         
     620        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     621//      err = V_KillNamedDataFolder(fname) 
     622//      if(err) 
     623//              Print "DataFolder kill err = ",err 
     624//      endif 
     625                 
     626        return(err) 
     627end 
     628 
     629Function V_writeCount_start(fname,str) 
     630        String fname,str 
    633631         
    634632//      String path = "entry:control:count_start"        
    635          
    636         Make/O/D/N=1 wTmpWrite 
    637 //      Make/O/R/N=1 wTmpWrite 
    638         String groupName = "/entry/control"      
     633 
     634        Make/O/T/N=1 tmpTW 
     635        String groupName = "/entry/control"     //       
    639636        String varName = "count_start" 
    640         wTmpWrite[0] = val 
    641  
    642         variable err 
    643         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    644         if(err) 
    645                 Print "HDF write err = ",err 
    646         endif 
    647         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    648 //      err = V_KillNamedDataFolder(fname) 
    649 //      if(err) 
    650 //              Print "DataFolder kill err = ",err 
    651 //      endif 
     637        tmpTW[0] = str // 
     638 
     639        variable err 
     640        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     641        if(err) 
     642                Print "HDF write err = ",err 
     643        endif 
     644         
     645        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     646//      err = V_KillNamedDataFolder(fname) 
     647//      if(err) 
     648//              Print "DataFolder kill err = ",err 
     649//      endif 
     650                 
    652651        return(err) 
    653652end 
     
    971970// TODO - verify the format of how these are written out to the file 
    972971// 
    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 
    997  
    998972 
    999973// transmission value for the attenuator in the beam 
     
    11031077        return(err) 
    11041078end 
     1079 
    11051080 
    11061081// table of the attenuation factor error 
     
    11871162//End 
    11881163 
    1189 // number of attenuators actually dropped in 
    1190 // an integer value 
    1191 Function 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) 
    1214 end 
     1164//// number of attenuators actually dropped in 
     1165//// an integer value 
     1166//Function V_writeAtten_num_dropped(fname,val) 
     1167//      String fname 
     1168//      Variable val 
     1169//       
     1170////    String path = "entry:instrument:attenuator:thickness"    
     1171//       
     1172//      Make/O/I/N=1 wTmpWrite 
     1173////    Make/O/R/N=1 wTmpWrite 
     1174//      String groupName = "/entry/instrument/attenuator"        
     1175//      String varName = "num_atten_dropped" 
     1176//      wTmpWrite[0] = val 
     1177// 
     1178//      variable err 
     1179//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1180//      if(err) 
     1181//              Print "HDF write err = ",err 
     1182//      endif 
     1183//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1184////    err = V_KillNamedDataFolder(fname) 
     1185////    if(err) 
     1186////            Print "DataFolder kill err = ",err 
     1187////    endif 
     1188//      return(err) 
     1189//end 
    12151190 
    12161191// thickness of the attenuator (PMMA) - units?? 
     
    12681243 
    12691244 
     1245 
     1246 
    12701247////// INSTRUMENT/BEAM 
     1248// 
     1249Function V_writeAnalyzer_depth(fname,val) 
     1250        String fname 
     1251        Variable val 
     1252         
     1253//      String path = "entry:instrument:beam:analyzer:depth" 
     1254 
     1255        Make/O/D/N=1 wTmpWrite 
     1256//      Make/O/R/N=1 wTmpWrite 
     1257        String groupName = "/entry/instrument/beam/analyzer"     
     1258        String varName = "depth" 
     1259        wTmpWrite[0] = val 
     1260 
     1261        variable err 
     1262        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1263        if(err) 
     1264                Print "HDF write err = ",err 
     1265        endif 
     1266        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1267//      err = V_KillNamedDataFolder(fname) 
     1268//      if(err) 
     1269//              Print "DataFolder kill err = ",err 
     1270//      endif 
     1271        return(err) 
     1272end 
     1273 
     1274Function V_writeAnalyzer_direction(fname,str) 
     1275        String fname,str 
     1276 
     1277//      String path = "entry:instrument:beam:analyzer:direction" 
     1278 
     1279        Make/O/T/N=1 tmpTW 
     1280        String groupName = "/entry/instrument/beam/analyzer"    //       
     1281        String varName = "direction" 
     1282        tmpTW[0] = str // 
     1283 
     1284        variable err 
     1285        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     1286        if(err) 
     1287                Print "HDF write err = ",err 
     1288        endif 
     1289         
     1290        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1291//      err = V_KillNamedDataFolder(fname) 
     1292//      if(err) 
     1293//              Print "DataFolder kill err = ",err 
     1294//      endif 
     1295                 
     1296        return(err) 
     1297End 
     1298 
     1299Function V_writeAnalyzer_height(fname,val) 
     1300        String fname 
     1301        Variable val 
     1302         
     1303//      String path = "entry:instrument:beam:analyzer:height"    
     1304 
     1305        Make/O/D/N=1 wTmpWrite 
     1306//      Make/O/R/N=1 wTmpWrite 
     1307        String groupName = "/entry/instrument/beam/analyzer"     
     1308        String varName = "height" 
     1309        wTmpWrite[0] = val 
     1310 
     1311        variable err 
     1312        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1313        if(err) 
     1314                Print "HDF write err = ",err 
     1315        endif 
     1316        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1317//      err = V_KillNamedDataFolder(fname) 
     1318//      if(err) 
     1319//              Print "DataFolder kill err = ",err 
     1320//      endif 
     1321        return(err) 
     1322end 
     1323 
     1324// ?? TODO is this equivalent to "status" -- is this 0|1 ?? 
     1325Function V_writeAnalyzer_inBeam(fname,val) 
     1326        String fname 
     1327        Variable val 
     1328         
     1329//      String path = "entry:instrument:beam:analyzer:inBeam"    
     1330 
     1331        Make/O/D/N=1 wTmpWrite 
     1332//      Make/O/R/N=1 wTmpWrite 
     1333        String groupName = "/entry/instrument/beam/analyzer"     
     1334        String varName = "inBeam" 
     1335        wTmpWrite[0] = val 
     1336 
     1337        variable err 
     1338        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1339        if(err) 
     1340                Print "HDF write err = ",err 
     1341        endif 
     1342        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1343//      err = V_KillNamedDataFolder(fname) 
     1344//      if(err) 
     1345//              Print "DataFolder kill err = ",err 
     1346//      endif 
     1347        return(err) 
     1348end 
     1349 
     1350Function V_writeAnalyzer_innerDiameter(fname,val) 
     1351        String fname 
     1352        Variable val 
     1353         
     1354//      String path = "entry:instrument:beam:analyzer:innerDiameter"     
     1355 
     1356        Make/O/D/N=1 wTmpWrite 
     1357//      Make/O/R/N=1 wTmpWrite 
     1358        String groupName = "/entry/instrument/beam/analyzer"     
     1359        String varName = "innerDiameter" 
     1360        wTmpWrite[0] = val 
     1361 
     1362        variable err 
     1363        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1364        if(err) 
     1365                Print "HDF write err = ",err 
     1366        endif 
     1367        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1368//      err = V_KillNamedDataFolder(fname) 
     1369//      if(err) 
     1370//              Print "DataFolder kill err = ",err 
     1371//      endif 
     1372        return(err) 
     1373end 
     1374 
     1375// one of the most important 
     1376Function V_writeAnalyzer_name(fname,str) 
     1377        String fname,str 
     1378 
     1379//      String path = "entry:instrument:beam:analyzer:name" 
     1380 
     1381        Make/O/T/N=1 tmpTW 
     1382        String groupName = "/entry/instrument/beam/analyzer"    //       
     1383        String varName = "name" 
     1384        tmpTW[0] = str // 
     1385 
     1386        variable err 
     1387        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     1388        if(err) 
     1389                Print "HDF write err = ",err 
     1390        endif 
     1391         
     1392        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1393//      err = V_KillNamedDataFolder(fname) 
     1394//      if(err) 
     1395//              Print "DataFolder kill err = ",err 
     1396//      endif 
     1397                 
     1398        return(err) 
     1399End 
     1400 
     1401Function V_writeAnalyzer_opacityAt1Ang(fname,val) 
     1402        String fname 
     1403        Variable val 
     1404         
     1405//      String path = "entry:instrument:beam:analyzer:opacityAt1Ang"     
     1406 
     1407        Make/O/D/N=1 wTmpWrite 
     1408//      Make/O/R/N=1 wTmpWrite 
     1409        String groupName = "/entry/instrument/beam/analyzer"     
     1410        String varName = "opacityAt1Ang" 
     1411        wTmpWrite[0] = val 
     1412 
     1413        variable err 
     1414        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1415        if(err) 
     1416                Print "HDF write err = ",err 
     1417        endif 
     1418        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1419//      err = V_KillNamedDataFolder(fname) 
     1420//      if(err) 
     1421//              Print "DataFolder kill err = ",err 
     1422//      endif 
     1423        return(err) 
     1424end 
     1425 
     1426Function V_writeAna_opacityAt1Ang_err(fname,val) 
     1427        String fname 
     1428        Variable val 
     1429         
     1430//      String path = "entry:instrument:beam:analyzer:opacityAt1AngStd"  
     1431 
     1432        Make/O/D/N=1 wTmpWrite 
     1433//      Make/O/R/N=1 wTmpWrite 
     1434        String groupName = "/entry/instrument/beam/analyzer"     
     1435        String varName = "opacityAt1AngStd" 
     1436        wTmpWrite[0] = val 
     1437 
     1438        variable err 
     1439        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1440        if(err) 
     1441                Print "HDF write err = ",err 
     1442        endif 
     1443        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1444//      err = V_KillNamedDataFolder(fname) 
     1445//      if(err) 
     1446//              Print "DataFolder kill err = ",err 
     1447//      endif 
     1448        return(err) 
     1449end 
     1450 
     1451Function V_writeAnalyzer_outerDiameter(fname,val) 
     1452        String fname 
     1453        Variable val 
     1454         
     1455//      String path = "entry:instrument:beam:analyzer:outerDiameter"     
     1456 
     1457        Make/O/D/N=1 wTmpWrite 
     1458//      Make/O/R/N=1 wTmpWrite 
     1459        String groupName = "/entry/instrument/beam/analyzer"     
     1460        String varName = "outerDiameter" 
     1461        wTmpWrite[0] = val 
     1462 
     1463        variable err 
     1464        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1465        if(err) 
     1466                Print "HDF write err = ",err 
     1467        endif 
     1468        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1469//      err = V_KillNamedDataFolder(fname) 
     1470//      if(err) 
     1471//              Print "DataFolder kill err = ",err 
     1472//      endif 
     1473        return(err) 
     1474end 
     1475 
     1476Function V_writeAnalyzer_shape(fname,str) 
     1477        String fname,str 
     1478 
     1479//      String path = "entry:instrument:beam:analyzer:shape" 
     1480 
     1481        Make/O/T/N=1 tmpTW 
     1482        String groupName = "/entry/instrument/beam/analyzer"    //       
     1483        String varName = "shape" 
     1484        tmpTW[0] = str // 
     1485 
     1486        variable err 
     1487        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     1488        if(err) 
     1489                Print "HDF write err = ",err 
     1490        endif 
     1491         
     1492        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1493//      err = V_KillNamedDataFolder(fname) 
     1494//      if(err) 
     1495//              Print "DataFolder kill err = ",err 
     1496//      endif 
     1497                 
     1498        return(err) 
     1499End 
     1500 
     1501Function V_writeAnalyzer_tE(fname,val) 
     1502        String fname 
     1503        Variable val 
     1504                 
     1505//      String path = "entry:instrument:beam:analyzer:tE"        
     1506 
     1507        Make/O/D/N=1 wTmpWrite 
     1508//      Make/O/R/N=1 wTmpWrite 
     1509        String groupName = "/entry/instrument/beam/analyzer"     
     1510        String varName = "tE" 
     1511        wTmpWrite[0] = val 
     1512 
     1513        variable err 
     1514        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1515        if(err) 
     1516                Print "HDF write err = ",err 
     1517        endif 
     1518        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1519//      err = V_KillNamedDataFolder(fname) 
     1520//      if(err) 
     1521//              Print "DataFolder kill err = ",err 
     1522//      endif 
     1523        return(err) 
     1524end 
     1525 
     1526Function V_writeAnalyzer_tE_err(fname,val) 
     1527        String fname 
     1528        Variable val 
     1529         
     1530//      String path = "entry:instrument:beam:analyzer:tEStd"     
     1531 
     1532        Make/O/D/N=1 wTmpWrite 
     1533//      Make/O/R/N=1 wTmpWrite 
     1534        String groupName = "/entry/instrument/beam/analyzer"     
     1535        String varName = "tEStd" 
     1536        wTmpWrite[0] = val 
     1537 
     1538        variable err 
     1539        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1540        if(err) 
     1541                Print "HDF write err = ",err 
     1542        endif 
     1543        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1544//      err = V_KillNamedDataFolder(fname) 
     1545//      if(err) 
     1546//              Print "DataFolder kill err = ",err 
     1547//      endif 
     1548        return(err) 
     1549end 
     1550 
     1551Function V_writeAnalyzer_type(fname,str) 
     1552        String fname,str 
     1553 
     1554//      String path = "entry:instrument:beam:analyzer:type" 
     1555 
     1556        Make/O/T/N=1 tmpTW 
     1557        String groupName = "/entry/instrument/beam/analyzer"    //       
     1558        String varName = "type" 
     1559        tmpTW[0] = str // 
     1560 
     1561        variable err 
     1562        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     1563        if(err) 
     1564                Print "HDF write err = ",err 
     1565        endif 
     1566         
     1567        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1568//      err = V_KillNamedDataFolder(fname) 
     1569//      if(err) 
     1570//              Print "DataFolder kill err = ",err 
     1571//      endif 
     1572                 
     1573        return(err) 
     1574End 
     1575 
     1576 
     1577Function V_writeAnalyzer_width(fname,val) 
     1578        String fname 
     1579        Variable val 
     1580         
     1581//      String path = "entry:instrument:beam:analyzer:width"     
     1582 
     1583        Make/O/D/N=1 wTmpWrite 
     1584//      Make/O/R/N=1 wTmpWrite 
     1585        String groupName = "/entry/instrument/beam/analyzer"     
     1586        String varName = "width" 
     1587        wTmpWrite[0] = val 
     1588 
     1589        variable err 
     1590        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1591        if(err) 
     1592                Print "HDF write err = ",err 
     1593        endif 
     1594        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1595//      err = V_KillNamedDataFolder(fname) 
     1596//      if(err) 
     1597//              Print "DataFolder kill err = ",err 
     1598//      endif 
     1599        return(err) 
     1600end 
     1601 
     1602 
     1603 
     1604 
     1605 
    12711606// instrument/beam/chopper (data folder) 
    12721607Function V_writeChopperAngular_opening(fname,val) 
     
    14721807 
    14731808 
    1474 // instrument/beam/flipper (data folder) 
    1475 Function V_writeFlipperDriving_current(fname,val) 
    1476         String fname 
    1477         Variable val 
    1478          
    1479 //      String path = "entry:instrument:beam:flipper:driving_current"    
    1480          
    1481         Make/O/D/N=1 wTmpWrite 
    1482 //      Make/O/R/N=1 wTmpWrite 
    1483         String groupName = "/entry/instrument/beam/flipper"      
    1484         String varName = "driving_current" 
    1485         wTmpWrite[0] = val 
    1486  
    1487         variable err 
    1488         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    1489         if(err) 
    1490                 Print "HDF write err = ",err 
    1491         endif 
    1492         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    1493 //      err = V_KillNamedDataFolder(fname) 
    1494 //      if(err) 
    1495 //              Print "DataFolder kill err = ",err 
    1496 //      endif 
    1497         return(err) 
    1498 end 
    1499  
    1500 Function V_writeFlipperFrequency(fname,val) 
    1501         String fname 
    1502         Variable val 
    1503          
    1504 //      String path = "entry:instrument:beam:flipper:frequency"  
    1505          
    1506         Make/O/D/N=1 wTmpWrite 
    1507 //      Make/O/R/N=1 wTmpWrite 
    1508         String groupName = "/entry/instrument/beam/flipper"      
    1509         String varName = "frequency" 
    1510         wTmpWrite[0] = val 
    1511  
    1512         variable err 
    1513         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    1514         if(err) 
    1515                 Print "HDF write err = ",err 
    1516         endif 
    1517         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    1518 //      err = V_KillNamedDataFolder(fname) 
    1519 //      if(err) 
    1520 //              Print "DataFolder kill err = ",err 
    1521 //      endif 
    1522         return(err) 
    1523 end 
    1524  
    1525 Function V_writeFlipperstatus(fname,str) 
    1526         String fname,str 
    1527  
    1528 //      String path = "entry:instrument:beam:flipper:status" 
    1529  
    1530         Make/O/T/N=1 tmpTW 
    1531         String groupName = "/entry/instrument/beam/flipper"     //       
    1532         String varName = "status" 
    1533         tmpTW[0] = str // 
    1534  
    1535         variable err 
    1536         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    1537         if(err) 
    1538                 Print "HDF write err = ",err 
    1539         endif 
    1540          
    1541         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    1542 //      err = V_KillNamedDataFolder(fname) 
    1543 //      if(err) 
    1544 //              Print "DataFolder kill err = ",err 
    1545 //      endif 
    1546                  
    1547         return(err) 
    1548 End 
    1549  
    1550 Function V_writeFlipperTransmitted_power(fname,val) 
    1551         String fname 
    1552         Variable val 
    1553          
    1554 //      String path = "entry:instrument:beam:flipper:transmitted_power"  
    1555  
    1556         Make/O/D/N=1 wTmpWrite 
    1557 //      Make/O/R/N=1 wTmpWrite 
    1558         String groupName = "/entry/instrument/beam/flipper"      
    1559         String varName = "transmitted_power" 
    1560         wTmpWrite[0] = val 
    1561  
    1562         variable err 
    1563         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    1564         if(err) 
    1565                 Print "HDF write err = ",err 
    1566         endif 
    1567         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    1568 //      err = V_KillNamedDataFolder(fname) 
    1569 //      if(err) 
    1570 //              Print "DataFolder kill err = ",err 
    1571 //      endif 
    1572         return(err) 
    1573 end 
    1574  
    1575 Function V_writeFlipperWaveform(fname,str) 
    1576         String fname,str 
    1577  
    1578 //      String path = "entry:instrument:beam:flipper:waveform" 
    1579  
    1580         Make/O/T/N=1 tmpTW 
    1581         String groupName = "/entry/instrument/beam/flipper"     //       
    1582         String varName = "waveform" 
    1583         tmpTW[0] = str // 
    1584  
    1585         variable err 
    1586         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    1587         if(err) 
    1588                 Print "HDF write err = ",err 
    1589         endif 
    1590          
    1591         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    1592 //      err = V_KillNamedDataFolder(fname) 
    1593 //      if(err) 
    1594 //              Print "DataFolder kill err = ",err 
    1595 //      endif 
    1596                  
    1597         return(err) 
    1598 End 
     1809/////////////// 
     1810// instrument/beam/flipperPolarizer (data folder) 
     1811// this is upstream, after the supermirror but before the sample 
     1812// 
     1813Function V_writeflipperPol_Direction(fname,str) 
     1814        String fname,str 
     1815 
     1816//      String path = "entry:instrument:beam:flipperPolarizer:direction" 
     1817 
     1818        Make/O/T/N=1 tmpTW 
     1819        String groupName = "/entry/instrument/beam/flipperPolarizer"    //       
     1820        String varName = "direction" 
     1821        tmpTW[0] = str // 
     1822 
     1823        variable err 
     1824        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     1825        if(err) 
     1826                Print "HDF write err = ",err 
     1827        endif 
     1828         
     1829        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1830//      err = V_KillNamedDataFolder(fname) 
     1831//      if(err) 
     1832//              Print "DataFolder kill err = ",err 
     1833//      endif 
     1834                 
     1835        return(err) 
     1836End 
     1837 
     1838Function V_writeflipperPolarizer_inBeam(fname,val) 
     1839        String fname 
     1840        Variable val 
     1841         
     1842//      String path = "entry:instrument:beam:flipperPolarizer:inBeam"    
     1843 
     1844        Make/O/D/N=1 wTmpWrite 
     1845//      Make/O/R/N=1 wTmpWrite 
     1846        String groupName = "/entry/instrument/beam/flipperPolarizer"     
     1847        String varName = "inBeam" 
     1848        wTmpWrite[0] = val 
     1849 
     1850        variable err 
     1851        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1852        if(err) 
     1853                Print "HDF write err = ",err 
     1854        endif 
     1855        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1856//      err = V_KillNamedDataFolder(fname) 
     1857//      if(err) 
     1858//              Print "DataFolder kill err = ",err 
     1859//      endif 
     1860        return(err) 
     1861end 
     1862 
     1863Function V_writeflipperPolarizer_Type(fname,str) 
     1864        String fname,str 
     1865 
     1866//      String path = "entry:instrument:beam:flipperPolarizer:type" 
     1867        Make/O/T/N=1 tmpTW 
     1868        String groupName = "/entry/instrument/beam/flipperPolarizer"    //       
     1869        String varName = "type" 
     1870        tmpTW[0] = str // 
     1871 
     1872        variable err 
     1873        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     1874        if(err) 
     1875                Print "HDF write err = ",err 
     1876        endif 
     1877         
     1878        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1879//      err = V_KillNamedDataFolder(fname) 
     1880//      if(err) 
     1881//              Print "DataFolder kill err = ",err 
     1882//      endif 
     1883                 
     1884        return(err) 
     1885End 
     1886 
     1887 
     1888 
     1889 
     1890////////// 
     1891//// instrument/beam/flipper (data folder) 
     1892//Function V_writeFlipperDriving_current(fname,val) 
     1893//      String fname 
     1894//      Variable val 
     1895//       
     1896////    String path = "entry:instrument:beam:flipper:driving_current"    
     1897//       
     1898//      Make/O/D/N=1 wTmpWrite 
     1899////    Make/O/R/N=1 wTmpWrite 
     1900//      String groupName = "/entry/instrument/beam/flipper"      
     1901//      String varName = "driving_current" 
     1902//      wTmpWrite[0] = val 
     1903// 
     1904//      variable err 
     1905//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1906//      if(err) 
     1907//              Print "HDF write err = ",err 
     1908//      endif 
     1909//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1910////    err = V_KillNamedDataFolder(fname) 
     1911////    if(err) 
     1912////            Print "DataFolder kill err = ",err 
     1913////    endif 
     1914//      return(err) 
     1915//end 
     1916// 
     1917//Function V_writeFlipperFrequency(fname,val) 
     1918//      String fname 
     1919//      Variable val 
     1920//       
     1921////    String path = "entry:instrument:beam:flipper:frequency"  
     1922//       
     1923//      Make/O/D/N=1 wTmpWrite 
     1924////    Make/O/R/N=1 wTmpWrite 
     1925//      String groupName = "/entry/instrument/beam/flipper"      
     1926//      String varName = "frequency" 
     1927//      wTmpWrite[0] = val 
     1928// 
     1929//      variable err 
     1930//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1931//      if(err) 
     1932//              Print "HDF write err = ",err 
     1933//      endif 
     1934//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1935////    err = V_KillNamedDataFolder(fname) 
     1936////    if(err) 
     1937////            Print "DataFolder kill err = ",err 
     1938////    endif 
     1939//      return(err) 
     1940//end 
     1941// 
     1942//Function V_writeFlipperstatus(fname,str) 
     1943//      String fname,str 
     1944// 
     1945////    String path = "entry:instrument:beam:flipper:status" 
     1946// 
     1947//      Make/O/T/N=1 tmpTW 
     1948//      String groupName = "/entry/instrument/beam/flipper"     //       
     1949//      String varName = "status" 
     1950//      tmpTW[0] = str // 
     1951// 
     1952//      variable err 
     1953//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     1954//      if(err) 
     1955//              Print "HDF write err = ",err 
     1956//      endif 
     1957//       
     1958//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1959////    err = V_KillNamedDataFolder(fname) 
     1960////    if(err) 
     1961////            Print "DataFolder kill err = ",err 
     1962////    endif 
     1963//               
     1964//      return(err) 
     1965//End 
     1966// 
     1967//Function V_writeFlipperTransmitted_power(fname,val) 
     1968//      String fname 
     1969//      Variable val 
     1970//       
     1971////    String path = "entry:instrument:beam:flipper:transmitted_power"  
     1972// 
     1973//      Make/O/D/N=1 wTmpWrite 
     1974////    Make/O/R/N=1 wTmpWrite 
     1975//      String groupName = "/entry/instrument/beam/flipper"      
     1976//      String varName = "transmitted_power" 
     1977//      wTmpWrite[0] = val 
     1978// 
     1979//      variable err 
     1980//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     1981//      if(err) 
     1982//              Print "HDF write err = ",err 
     1983//      endif 
     1984//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     1985////    err = V_KillNamedDataFolder(fname) 
     1986////    if(err) 
     1987////            Print "DataFolder kill err = ",err 
     1988////    endif 
     1989//      return(err) 
     1990//end 
     1991// 
     1992//Function V_writeFlipperWaveform(fname,str) 
     1993//      String fname,str 
     1994// 
     1995////    String path = "entry:instrument:beam:flipper:waveform" 
     1996// 
     1997//      Make/O/T/N=1 tmpTW 
     1998//      String groupName = "/entry/instrument/beam/flipper"     //       
     1999//      String varName = "waveform" 
     2000//      tmpTW[0] = str // 
     2001// 
     2002//      variable err 
     2003//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     2004//      if(err) 
     2005//              Print "HDF write err = ",err 
     2006//      endif 
     2007//       
     2008//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2009////    err = V_KillNamedDataFolder(fname) 
     2010////    if(err) 
     2011////            Print "DataFolder kill err = ",err 
     2012////    endif 
     2013//               
     2014//      return(err) 
     2015//End 
     2016 
     2017 
    15992018 
    16002019// instrument/beam/monochromator (data folder) 
     
    16802099 
    16812100// instrument/beam/monochromator/crystal (data folder) 
     2101// 
     2102Function V_writeCrystalDistance(fname,val) 
     2103        String fname 
     2104        Variable val 
     2105         
     2106//      String path = "entry:instrument:beam:monochromator:crystal:distance"     
     2107         
     2108        Make/O/D/N=1 wTmpWrite 
     2109//      Make/O/R/N=1 wTmpWrite 
     2110        String groupName = "/entry/instrument/beam/monochromator/crystal"        
     2111        String varName = "distance" 
     2112        wTmpWrite[0] = val 
     2113 
     2114        variable err 
     2115        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     2116        if(err) 
     2117                Print "HDF write err = ",err 
     2118        endif 
     2119        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2120//      err = V_KillNamedDataFolder(fname) 
     2121//      if(err) 
     2122//              Print "DataFolder kill err = ",err 
     2123//      endif 
     2124        return(err) 
     2125end 
     2126 
    16822127Function V_writeCrystalEnergy(fname,val) 
    16832128        String fname 
     
    17802225end 
    17812226 
    1782 Function V_writeCrystalDistance(fname,val) 
    1783         String fname 
    1784         Variable val 
    1785          
    1786 //      String path = "entry:instrument:beam:monochromator:crystal:distance"     
    1787          
    1788         Make/O/D/N=1 wTmpWrite 
    1789 //      Make/O/R/N=1 wTmpWrite 
    1790         String groupName = "/entry/instrument/beam/monochromator/crystal"        
    1791         String varName = "distance" 
    1792         wTmpWrite[0] = val 
    1793  
    1794         variable err 
    1795         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    1796         if(err) 
    1797                 Print "HDF write err = ",err 
    1798         endif 
    1799         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    1800 //      err = V_KillNamedDataFolder(fname) 
    1801 //      if(err) 
    1802 //              Print "DataFolder kill err = ",err 
    1803 //      endif 
    1804         return(err) 
    1805 end 
    18062227 
    18072228Function V_writeCrystalReflection(fname,val) 
     
    20052426end 
    20062427 
     2428//////////// 
    20072429// instrument/beam/monochromator/velocity_selector (data folder) 
    20082430Function V_writeVSDistance(fname,val) 
     
    22602682end 
    22612683 
    2262 // instrument/beam/polarizer (data folder) 
     2684// instrument/beam/superMirror (data folder) 
     2685// This is the upstream polarizer. There are no other choices for polarizer on VSANS 
    22632686Function V_writePolarizerComposition(fname,str) 
    22642687        String fname,str 
    22652688 
    2266 //      String path = "entry:instrument:beam:polarizer:composition" 
    2267  
    2268         Make/O/T/N=1 tmpTW 
    2269         String groupName = "/entry/instrument/beam/polarizer"   //       
     2689//      String path = "entry:instrument:beam:superMirror:composition" 
     2690 
     2691        Make/O/T/N=1 tmpTW 
     2692        String groupName = "/entry/instrument/beam/superMirror" //       
    22702693        String varName = "composition" 
    22712694        tmpTW[0] = str // 
     
    22902713        Variable val 
    22912714         
    2292 //      String path = "entry:instrument:beam:polarizer:efficiency"       
    2293          
    2294         Make/O/D/N=1 wTmpWrite 
    2295 //      Make/O/R/N=1 wTmpWrite 
    2296         String groupName = "/entry/instrument/beam/polarizer"    
     2715//      String path = "entry:instrument:beam:superMirror:efficiency"     
     2716         
     2717        Make/O/D/N=1 wTmpWrite 
     2718//      Make/O/R/N=1 wTmpWrite 
     2719        String groupName = "/entry/instrument/beam/superMirror"  
    22972720        String varName = "efficiency" 
    22982721        wTmpWrite[0] = val 
     
    23112734end 
    23122735 
    2313 Function V_writePolarizerStatus(fname,str) 
    2314         String fname,str 
    2315  
    2316 //      String path = "entry:instrument:beam:polarizer:status" 
    2317  
    2318         Make/O/T/N=1 tmpTW 
    2319         String groupName = "/entry/instrument/beam/polarizer"   //       
    2320         String varName = "status" 
    2321         tmpTW[0] = str // 
    2322  
    2323         variable err 
    2324         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    2325         if(err) 
    2326                 Print "HDF write err = ",err 
    2327         endif 
    2328          
    2329         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2330 //      err = V_KillNamedDataFolder(fname) 
    2331 //      if(err) 
    2332 //              Print "DataFolder kill err = ",err 
    2333 //      endif 
    2334                  
    2335         return(err) 
    2336 End 
    2337  
    2338 Function V_writePolarizerType(fname,str) 
    2339         String fname,str 
    2340  
    2341 //      String path = "entry:instrument:beam:polarizer:type" 
    2342  
    2343         Make/O/T/N=1 tmpTW 
    2344         String groupName = "/entry/instrument/beam/polarizer"   //       
    2345         String varName = "type" 
    2346         tmpTW[0] = str // 
    2347  
    2348         variable err 
    2349         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    2350         if(err) 
    2351                 Print "HDF write err = ",err 
    2352         endif 
    2353          
    2354         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2355 //      err = V_KillNamedDataFolder(fname) 
    2356 //      if(err) 
    2357 //              Print "DataFolder kill err = ",err 
    2358 //      endif 
    2359                  
    2360         return(err) 
    2361 End 
    2362  
    2363 // instrument/beam/polarizer_analyzer (data folder) 
    2364 // integer value 
    2365 Function V_writePolAnaCell_index(fname,val) 
    2366         String fname 
    2367         Variable val 
    2368  
    2369 //      String path = "entry:instrument:beam:polarizer_analyzer:cell_index" 
    2370          
    2371         Make/O/I/N=1 wTmpWrite 
    2372 //      Make/O/R/N=1 wTmpWrite 
    2373         String groupName = "/entry/instrument/beam/polarizer_analyzer"   
    2374         String varName = "cell_index" 
    2375         wTmpWrite[0] = val 
    2376  
    2377         variable err 
    2378         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    2379         if(err) 
    2380                 Print "HDF write err = ",err 
    2381         endif 
    2382         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2383 //      err = V_KillNamedDataFolder(fname) 
    2384 //      if(err) 
    2385 //              Print "DataFolder kill err = ",err 
    2386 //      endif 
    2387         return(err) 
    2388 End 
    2389  
    2390 Function V_writePolAnaCell_name(fname,str) 
    2391         String fname,str 
    2392  
    2393 //      String path = "entry:instrument:beam:polarizer_analyzer:cell_name" 
    2394  
    2395         Make/O/T/N=1 tmpTW 
    2396         String groupName = "/entry/instrument/beam/polarizer_analyzer"  //       
    2397         String varName = "cell_name" 
    2398         tmpTW[0] = str // 
    2399  
    2400         variable err 
    2401         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    2402         if(err) 
    2403                 Print "HDF write err = ",err 
    2404         endif 
    2405          
    2406         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2407 //      err = V_KillNamedDataFolder(fname) 
    2408 //      if(err) 
    2409 //              Print "DataFolder kill err = ",err 
    2410 //      endif 
    2411                  
    2412         return(err) 
    2413 End 
    2414  
    2415 Function V_writePolAnaCell_parameters(fname,inW) 
    2416         String fname 
    2417         Wave inW 
    2418  
    2419 //      String path = "entry:instrument:beam:polarizer_analyzer:cell_parameters" 
    2420  
    2421         Duplicate/O inW wTmpWrite        
    2422 // then use redimension as needed to cast the wave to write to the specified type 
    2423 // see WaveType for the proper codes  
    2424 //      Redimension/T=() wTmpWrite 
    2425 // -- May also need to check the dimension(s) before writing (don't trust the input) 
    2426         String groupName = "/entry/instrument//beam/polarizer_analyzer"  
    2427         String varName = "cell_parameters" 
    2428  
    2429         variable err 
    2430         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    2431         if(err) 
    2432                 Print "HDF write err = ",err 
    2433         endif 
    2434         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2435 //      err = V_KillNamedDataFolder(fname) 
    2436 //      if(err) 
    2437 //              Print "DataFolder kill err = ",err 
    2438 //      endif 
    2439         return(err) 
    2440 End 
    2441  
    2442 Function V_writePolAnaGuideFieldCur_1(fname,val) 
    2443         String fname 
    2444         Variable val 
    2445  
    2446 //      String path = "entry:instrument:beam:polarizer_analyzer:guide_field_current_1" 
    2447          
    2448         Make/O/D/N=1 wTmpWrite 
    2449 //      Make/O/R/N=1 wTmpWrite 
    2450         String groupName = "/entry/instrument/beam/polarizer_analyzer"   
    2451         String varName = "guide_field_current_1" 
    2452         wTmpWrite[0] = val 
    2453  
    2454         variable err 
    2455         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    2456         if(err) 
    2457                 Print "HDF write err = ",err 
    2458         endif 
    2459         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2460 //      err = V_KillNamedDataFolder(fname) 
    2461 //      if(err) 
    2462 //              Print "DataFolder kill err = ",err 
    2463 //      endif 
    2464         return(err) 
    2465 End 
    2466  
    2467 Function V_writePolAnaGuideFieldCur_2(fname,val) 
    2468         String fname 
    2469         Variable val 
    2470  
    2471 //      String path = "entry:instrument:beam:polarizer_analyzer:guide_field_current_2" 
    2472          
    2473         Make/O/D/N=1 wTmpWrite 
    2474 //      Make/O/R/N=1 wTmpWrite 
    2475         String groupName = "/entry/instrument/beam/polarizer_analyzer"   
    2476         String varName = "guide_field_current_2" 
    2477         wTmpWrite[0] = val 
    2478  
    2479         variable err 
    2480         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    2481         if(err) 
    2482                 Print "HDF write err = ",err 
    2483         endif 
    2484         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2485 //      err = V_KillNamedDataFolder(fname) 
    2486 //      if(err) 
    2487 //              Print "DataFolder kill err = ",err 
    2488 //      endif 
    2489         return(err) 
    2490 End 
    2491  
    2492 Function V_writePolAnaSolenoid_current(fname,val) 
    2493         String fname 
    2494         Variable val 
    2495  
    2496 //      String path = "entry:instrument:beam:polarizer_analyzer:solenoid_current" 
    2497          
    2498         Make/O/D/N=1 wTmpWrite 
    2499 //      Make/O/R/N=1 wTmpWrite 
    2500         String groupName = "/entry/instrument/beam/polarizer_analyzer"   
    2501         String varName = "solenoid_current" 
    2502         wTmpWrite[0] = val 
    2503  
    2504         variable err 
    2505         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    2506         if(err) 
    2507                 Print "HDF write err = ",err 
    2508         endif 
    2509         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2510 //      err = V_KillNamedDataFolder(fname) 
    2511 //      if(err) 
    2512 //              Print "DataFolder kill err = ",err 
    2513 //      endif 
    2514         return(err) 
    2515 End 
    2516  
    2517 Function V_writePolAnaStatus(fname,str) 
    2518         String fname,str 
    2519  
    2520 //      String path = "entry:instrument:beam:polarizer_analyzer:status" 
    2521  
    2522         Make/O/T/N=1 tmpTW 
    2523         String groupName = "/entry/instrument/beam/polarizer_analyzer"  //       
    2524         String varName = "status" 
    2525         tmpTW[0] = str // 
    2526  
    2527         variable err 
    2528         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    2529         if(err) 
    2530                 Print "HDF write err = ",err 
    2531         endif 
    2532          
    2533         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2534 //      err = V_KillNamedDataFolder(fname) 
    2535 //      if(err) 
    2536 //              Print "DataFolder kill err = ",err 
    2537 //      endif 
    2538                  
    2539         return(err) 
    2540 End 
     2736Function V_writePolarizerState(fname,str) 
     2737        String fname,str 
     2738 
     2739//      String path = "entry:instrument:beam:superMirror:state" 
     2740 
     2741        Make/O/T/N=1 tmpTW 
     2742        String groupName = "/entry/instrument/beam/superMirror" //       
     2743        String varName = "state" 
     2744        tmpTW[0] = str // 
     2745 
     2746        variable err 
     2747        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     2748        if(err) 
     2749                Print "HDF write err = ",err 
     2750        endif 
     2751         
     2752        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2753//      err = V_KillNamedDataFolder(fname) 
     2754//      if(err) 
     2755//              Print "DataFolder kill err = ",err 
     2756//      endif 
     2757                 
     2758        return(err) 
     2759End 
     2760 
     2761//Function V_writePolarizerType(fname,str) 
     2762//      String fname,str 
     2763// 
     2764////    String path = "entry:instrument:beam:polarizer:type" 
     2765// 
     2766//      Make/O/T/N=1 tmpTW 
     2767//      String groupName = "/entry/instrument/beam/polarizer"   //       
     2768//      String varName = "type" 
     2769//      tmpTW[0] = str // 
     2770// 
     2771//      variable err 
     2772//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     2773//      if(err) 
     2774//              Print "HDF write err = ",err 
     2775//      endif 
     2776//       
     2777//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2778////    err = V_KillNamedDataFolder(fname) 
     2779////    if(err) 
     2780////            Print "DataFolder kill err = ",err 
     2781////    endif 
     2782//               
     2783//      return(err) 
     2784//End 
     2785// 
     2786//// instrument/beam/polarizer_analyzer (data folder) 
     2787//// integer value 
     2788//Function V_writePolAnaCell_index(fname,val) 
     2789//      String fname 
     2790//      Variable val 
     2791// 
     2792////    String path = "entry:instrument:beam:polarizer_analyzer:cell_index" 
     2793//       
     2794//      Make/O/I/N=1 wTmpWrite 
     2795////    Make/O/R/N=1 wTmpWrite 
     2796//      String groupName = "/entry/instrument/beam/polarizer_analyzer"   
     2797//      String varName = "cell_index" 
     2798//      wTmpWrite[0] = val 
     2799// 
     2800//      variable err 
     2801//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     2802//      if(err) 
     2803//              Print "HDF write err = ",err 
     2804//      endif 
     2805//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2806////    err = V_KillNamedDataFolder(fname) 
     2807////    if(err) 
     2808////            Print "DataFolder kill err = ",err 
     2809////    endif 
     2810//      return(err) 
     2811//End 
     2812// 
     2813//Function V_writePolAnaCell_name(fname,str) 
     2814//      String fname,str 
     2815// 
     2816////    String path = "entry:instrument:beam:polarizer_analyzer:cell_name" 
     2817// 
     2818//      Make/O/T/N=1 tmpTW 
     2819//      String groupName = "/entry/instrument/beam/polarizer_analyzer"  //       
     2820//      String varName = "cell_name" 
     2821//      tmpTW[0] = str // 
     2822// 
     2823//      variable err 
     2824//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     2825//      if(err) 
     2826//              Print "HDF write err = ",err 
     2827//      endif 
     2828//       
     2829//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2830////    err = V_KillNamedDataFolder(fname) 
     2831////    if(err) 
     2832////            Print "DataFolder kill err = ",err 
     2833////    endif 
     2834//               
     2835//      return(err) 
     2836//End 
     2837// 
     2838//Function V_writePolAnaCell_parameters(fname,inW) 
     2839//      String fname 
     2840//      Wave inW 
     2841// 
     2842////    String path = "entry:instrument:beam:polarizer_analyzer:cell_parameters" 
     2843// 
     2844//      Duplicate/O inW wTmpWrite        
     2845//// then use redimension as needed to cast the wave to write to the specified type 
     2846//// see WaveType for the proper codes  
     2847////    Redimension/T=() wTmpWrite 
     2848//// -- May also need to check the dimension(s) before writing (don't trust the input) 
     2849//      String groupName = "/entry/instrument//beam/polarizer_analyzer"  
     2850//      String varName = "cell_parameters" 
     2851// 
     2852//      variable err 
     2853//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     2854//      if(err) 
     2855//              Print "HDF write err = ",err 
     2856//      endif 
     2857//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2858////    err = V_KillNamedDataFolder(fname) 
     2859////    if(err) 
     2860////            Print "DataFolder kill err = ",err 
     2861////    endif 
     2862//      return(err) 
     2863//End 
     2864// 
     2865//Function V_writePolAnaGuideFieldCur_1(fname,val) 
     2866//      String fname 
     2867//      Variable val 
     2868// 
     2869////    String path = "entry:instrument:beam:polarizer_analyzer:guide_field_current_1" 
     2870//       
     2871//      Make/O/D/N=1 wTmpWrite 
     2872////    Make/O/R/N=1 wTmpWrite 
     2873//      String groupName = "/entry/instrument/beam/polarizer_analyzer"   
     2874//      String varName = "guide_field_current_1" 
     2875//      wTmpWrite[0] = val 
     2876// 
     2877//      variable err 
     2878//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     2879//      if(err) 
     2880//              Print "HDF write err = ",err 
     2881//      endif 
     2882//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2883////    err = V_KillNamedDataFolder(fname) 
     2884////    if(err) 
     2885////            Print "DataFolder kill err = ",err 
     2886////    endif 
     2887//      return(err) 
     2888//End 
     2889// 
     2890//Function V_writePolAnaGuideFieldCur_2(fname,val) 
     2891//      String fname 
     2892//      Variable val 
     2893// 
     2894////    String path = "entry:instrument:beam:polarizer_analyzer:guide_field_current_2" 
     2895//       
     2896//      Make/O/D/N=1 wTmpWrite 
     2897////    Make/O/R/N=1 wTmpWrite 
     2898//      String groupName = "/entry/instrument/beam/polarizer_analyzer"   
     2899//      String varName = "guide_field_current_2" 
     2900//      wTmpWrite[0] = val 
     2901// 
     2902//      variable err 
     2903//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     2904//      if(err) 
     2905//              Print "HDF write err = ",err 
     2906//      endif 
     2907//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2908////    err = V_KillNamedDataFolder(fname) 
     2909////    if(err) 
     2910////            Print "DataFolder kill err = ",err 
     2911////    endif 
     2912//      return(err) 
     2913//End 
     2914// 
     2915//Function V_writePolAnaSolenoid_current(fname,val) 
     2916//      String fname 
     2917//      Variable val 
     2918// 
     2919////    String path = "entry:instrument:beam:polarizer_analyzer:solenoid_current" 
     2920//       
     2921//      Make/O/D/N=1 wTmpWrite 
     2922////    Make/O/R/N=1 wTmpWrite 
     2923//      String groupName = "/entry/instrument/beam/polarizer_analyzer"   
     2924//      String varName = "solenoid_current" 
     2925//      wTmpWrite[0] = val 
     2926// 
     2927//      variable err 
     2928//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     2929//      if(err) 
     2930//              Print "HDF write err = ",err 
     2931//      endif 
     2932//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2933////    err = V_KillNamedDataFolder(fname) 
     2934////    if(err) 
     2935////            Print "DataFolder kill err = ",err 
     2936////    endif 
     2937//      return(err) 
     2938//End 
     2939// 
     2940//Function V_writePolAnaStatus(fname,str) 
     2941//      String fname,str 
     2942// 
     2943////    String path = "entry:instrument:beam:polarizer_analyzer:status" 
     2944// 
     2945//      Make/O/T/N=1 tmpTW 
     2946//      String groupName = "/entry/instrument/beam/polarizer_analyzer"  //       
     2947//      String varName = "status" 
     2948//      tmpTW[0] = str // 
     2949// 
     2950//      variable err 
     2951//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     2952//      if(err) 
     2953//              Print "HDF write err = ",err 
     2954//      endif 
     2955//       
     2956//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     2957////    err = V_KillNamedDataFolder(fname) 
     2958////    if(err) 
     2959////            Print "DataFolder kill err = ",err 
     2960////    endif 
     2961//               
     2962//      return(err) 
     2963//End 
    25412964 
    25422965 
     
    25732996End 
    25742997 
     2998Function V_writeBeamMonLowDistance(fname,val) 
     2999        String fname 
     3000        Variable val 
     3001 
     3002//      String path = "entry:instrument:beam_monitor_low:distance" 
     3003         
     3004        Make/O/D/N=1 wTmpWrite 
     3005//      Make/O/R/N=1 wTmpWrite 
     3006        String groupName = "/entry/instrument/beam_monitor_low"  
     3007        String varName = "distance" 
     3008        wTmpWrite[0] = val 
     3009 
     3010        variable err 
     3011        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3012        if(err) 
     3013                Print "HDF write err = ",err 
     3014        endif 
     3015        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3016//      err = V_KillNamedDataFolder(fname) 
     3017//      if(err) 
     3018//              Print "DataFolder kill err = ",err 
     3019//      endif 
     3020        return(err) 
     3021End 
     3022 
    25753023Function V_writeBeamMonLowEfficiency(fname,val) 
    25763024        String fname 
     
    25833031        String groupName = "/entry/instrument/beam_monitor_low"  
    25843032        String varName = "efficiency" 
    2585         wTmpWrite[0] = val 
    2586  
    2587         variable err 
    2588         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    2589         if(err) 
    2590                 Print "HDF write err = ",err 
    2591         endif 
    2592         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2593 //      err = V_KillNamedDataFolder(fname) 
    2594 //      if(err) 
    2595 //              Print "DataFolder kill err = ",err 
    2596 //      endif 
    2597         return(err) 
    2598 End 
    2599  
    2600 Function V_writeBeamMonLowDistance(fname,val) 
    2601         String fname 
    2602         Variable val 
    2603  
    2604 //      String path = "entry:instrument:beam_monitor_low:distance" 
    2605          
    2606         Make/O/D/N=1 wTmpWrite 
    2607 //      Make/O/R/N=1 wTmpWrite 
    2608         String groupName = "/entry/instrument/beam_monitor_low"  
    2609         String varName = "distance" 
    26103033        wTmpWrite[0] = val 
    26113034 
     
    27003123End 
    27013124 
     3125Function V_writeBeamMonNormDistance(fname,val) 
     3126        String fname 
     3127        Variable val 
     3128 
     3129//      String path = "entry:instrument:beam_monitor_norm:distance" 
     3130         
     3131        Make/O/D/N=1 wTmpWrite 
     3132//      Make/O/R/N=1 wTmpWrite 
     3133        String groupName = "/entry/instrument/beam_monitor_norm"         
     3134        String varName = "distance" 
     3135        wTmpWrite[0] = val 
     3136 
     3137        variable err 
     3138        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     3139        if(err) 
     3140                Print "HDF write err = ",err 
     3141        endif 
     3142        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     3143//      err = V_KillNamedDataFolder(fname) 
     3144//      if(err) 
     3145//              Print "DataFolder kill err = ",err 
     3146//      endif 
     3147        return(err) 
     3148End 
     3149 
    27023150Function V_writeBeamMonNormEfficiency(fname,val) 
    27033151        String fname 
     
    27253173End 
    27263174 
    2727 Function V_writeBeamMonNormDistance(fname,val) 
    2728         String fname 
    2729         Variable val 
    2730  
    2731 //      String path = "entry:instrument:beam_monitor_norm:distance" 
    2732          
    2733         Make/O/D/N=1 wTmpWrite 
    2734 //      Make/O/R/N=1 wTmpWrite 
    2735         String groupName = "/entry/instrument/beam_monitor_norm"         
    2736         String varName = "distance" 
    2737         wTmpWrite[0] = val 
    2738  
    2739         variable err 
    2740         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    2741         if(err) 
    2742                 Print "HDF write err = ",err 
    2743         endif 
    2744         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    2745 //      err = V_KillNamedDataFolder(fname) 
    2746 //      if(err) 
    2747 //              Print "DataFolder kill err = ",err 
    2748 //      endif 
    2749         return(err) 
    2750 End 
    27513175 
    27523176Function V_writeBeamMonNormSaved_count(fname,val) 
     
    46485072         
    46495073 
    4650 ///////  sample_aperture (data folder) 
    4651  
     5074///////  sample_aperture (1) (data folder) 
     5075// this is the INTERNAL sample aperture 
    46525076Function V_writeSampleAp_Description(fname,str) 
    46535077        String fname,str 
     
    47005124End 
    47015125 
    4702 //      shape (data folder) 
     5126//      sample_apertuer/shape (data folder) 
     5127Function V_writeSampleAp_height(fname,val) 
     5128        String fname 
     5129        Variable val 
     5130 
     5131//      String path = "entry:instrument:sample_aperture:distance" 
     5132         
     5133        Make/O/D/N=1 wTmpWrite 
     5134//      Make/O/R/N=1 wTmpWrite 
     5135        String groupName = "/entry/instrument/sample_aperture/shape" 
     5136        String varName = "height" 
     5137        wTmpWrite[0] = val 
     5138 
     5139        variable err 
     5140        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     5141        if(err) 
     5142                Print "HDF write err = ",err 
     5143        endif 
     5144        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     5145//      err = V_KillNamedDataFolder(fname) 
     5146//      if(err) 
     5147//              Print "DataFolder kill err = ",err 
     5148//      endif 
     5149        return(err) 
     5150End 
    47035151 
    47045152Function V_writeSampleAp_shape(fname,str) 
     
    47275175End 
    47285176 
    4729 Function V_writeSampleAp_height(fname,val) 
    4730         String fname 
    4731         Variable val 
    4732  
    4733 //      String path = "entry:instrument:sample_aperture:distance" 
    4734          
    4735         Make/O/D/N=1 wTmpWrite 
    4736 //      Make/O/R/N=1 wTmpWrite 
    4737         String groupName = "/entry/instrument/sample_aperture/shape" 
    4738         String varName = "height" 
    4739         wTmpWrite[0] = val 
    4740  
    4741         variable err 
    4742         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    4743         if(err) 
    4744                 Print "HDF write err = ",err 
    4745         endif 
    4746         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    4747 //      err = V_KillNamedDataFolder(fname) 
    4748 //      if(err) 
    4749 //              Print "DataFolder kill err = ",err 
    4750 //      endif 
    4751         return(err) 
    4752 End 
    4753  
    47545177Function V_writeSampleAp_size(fname,str) 
    47555178        String fname,str 
     
    48035226 
    48045227///////  sample_aperture_2 (data folder) 
     5228// sample aperture (2) is the external aperture, which may or may not be present 
    48055229 
    48065230Function V_writeSampleAp2_Description(fname,str) 
     
    48565280 
    48575281//      shape (data folder) 
     5282Function V_writeSampleAp2_height(fname,val) 
     5283        String fname 
     5284        Variable val 
     5285 
     5286//      String path = "entry:instrument:sample_aperture:distance" 
     5287         
     5288        Make/O/D/N=1 wTmpWrite 
     5289//      Make/O/R/N=1 wTmpWrite 
     5290        String groupName = "/entry/instrument/sample_aperture_2/shape" 
     5291        String varName = "height" 
     5292        wTmpWrite[0] = val 
     5293 
     5294        variable err 
     5295        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     5296        if(err) 
     5297                Print "HDF write err = ",err 
     5298        endif 
     5299        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     5300//      err = V_KillNamedDataFolder(fname) 
     5301//      if(err) 
     5302//              Print "DataFolder kill err = ",err 
     5303//      endif 
     5304        return(err) 
     5305End 
    48585306 
    48595307Function V_writeSampleAp2_shape(fname,str) 
     
    48795327//      endif 
    48805328                 
    4881         return(err) 
    4882 End 
    4883  
    4884 Function V_writeSampleAp2_height(fname,val) 
    4885         String fname 
    4886         Variable val 
    4887  
    4888 //      String path = "entry:instrument:sample_aperture:distance" 
    4889          
    4890         Make/O/D/N=1 wTmpWrite 
    4891 //      Make/O/R/N=1 wTmpWrite 
    4892         String groupName = "/entry/instrument/sample_aperture_2/shape" 
    4893         String varName = "height" 
    4894         wTmpWrite[0] = val 
    4895  
    4896         variable err 
    4897         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    4898         if(err) 
    4899                 Print "HDF write err = ",err 
    4900         endif 
    4901         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    4902 //      err = V_KillNamedDataFolder(fname) 
    4903 //      if(err) 
    4904 //              Print "DataFolder kill err = ",err 
    4905 //      endif 
    49065329        return(err) 
    49075330End 
     
    51695592        return(err) 
    51705593End 
     5594 
     5595 
    51715596//      shape (data folder) 
     5597Function V_writeSourceAp_height(fname,val) 
     5598        String fname 
     5599        Variable val 
     5600 
     5601//      String path = "entry:instrument:sample_aperture:distance" 
     5602         
     5603        Make/O/D/N=1 wTmpWrite 
     5604//      Make/O/R/N=1 wTmpWrite 
     5605        String groupName = "/entry/instrument/source_aperture/shape" 
     5606        String varName = "height" 
     5607        wTmpWrite[0] = val 
     5608 
     5609        variable err 
     5610        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     5611        if(err) 
     5612                Print "HDF write err = ",err 
     5613        endif 
     5614        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     5615//      err = V_KillNamedDataFolder(fname) 
     5616//      if(err) 
     5617//              Print "DataFolder kill err = ",err 
     5618//      endif 
     5619        return(err) 
     5620End 
    51725621 
    51735622Function V_writeSourceAp_shape(fname,str) 
     
    52185667//      endif 
    52195668                 
    5220         return(err) 
    5221 End 
    5222  
    5223 Function V_writeSourceAp_height(fname,val) 
    5224         String fname 
    5225         Variable val 
    5226  
    5227 //      String path = "entry:instrument:sample_aperture:distance" 
    5228          
    5229         Make/O/D/N=1 wTmpWrite 
    5230 //      Make/O/R/N=1 wTmpWrite 
    5231         String groupName = "/entry/instrument/source_aperture/shape" 
    5232         String varName = "height" 
    5233         wTmpWrite[0] = val 
    5234  
    5235         variable err 
    5236         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    5237         if(err) 
    5238                 Print "HDF write err = ",err 
    5239         endif 
    5240         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    5241 //      err = V_KillNamedDataFolder(fname) 
    5242 //      if(err) 
    5243 //              Print "DataFolder kill err = ",err 
    5244 //      endif 
    52455669        return(err) 
    52465670End 
     
    55235947         
    55245948        String path = "entry:sample:transmission"        
    5525 //      String path = "QKK0037737:data:Transmission"     
    55265949         
    55275950        Make/O/D/N=1 wTmpWrite 
     
    55776000// temperature_1 
    55786001// temperature_2 
     6002// temperature_3 
     6003// temperature_4 
    55796004// shear_field 
    55806005// pressure 
     
    56626087 
    56636088 
    5664 // TODO --  
     6089// TODO -- this may require multiple entries, for each sensor _1, _2, etc. 
     6090Function V_writeLog_setPoint(fname,logStr,val) 
     6091        String fname,logStr 
     6092        Variable val 
     6093         
     6094//      String path = "entry:sample:"+logstr+":setpoint_1" 
     6095         
     6096        Make/O/D/N=1 wTmpWrite 
     6097//      Make/O/R/N=1 wTmpWrite 
     6098        String groupName = "/entry/sample/"+logStr 
     6099        String varName = "setpoint_1" 
     6100        wTmpWrite[0] = val 
     6101 
     6102        variable err 
     6103        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     6104        if(err) 
     6105                Print "HDF write err = ",err 
     6106        endif 
     6107        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6108//      err = V_KillNamedDataFolder(fname) 
     6109//      if(err) 
     6110//              Print "DataFolder kill err = ",err 
     6111//      endif 
     6112        return(err) 
     6113end 
     6114 
     6115Function V_writeLog_startTime(fname,logStr,str) 
     6116        String fname,logStr,str 
     6117 
     6118//      String path = "entry:sample:"+logstr+":start" 
     6119 
     6120        Make/O/T/N=1 tmpTW 
     6121        String groupName = "/entry/sample/"+logStr 
     6122        String varName = "start" 
     6123        tmpTW[0] = str // 
     6124 
     6125        variable err 
     6126        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6127        if(err) 
     6128                Print "HDF write err = ",err 
     6129        endif 
     6130         
     6131        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6132//      err = V_KillNamedDataFolder(fname) 
     6133//      if(err) 
     6134//              Print "DataFolder kill err = ",err 
     6135//      endif 
     6136                 
     6137        return(err) 
     6138End 
     6139 
     6140 
     6141// TODO -- this may only exist for electric and magnetic field, or be removed 
    56656142Function V_writeLog_nomValue(fname,logStr,val) 
    56666143        String fname,logStr 
     
    56896166 
    56906167////            value_log (data folder) 
    5691 Function V_writeLog_startTime(fname,logStr,str) 
    5692         String fname,logStr,str 
    5693  
    5694 //      String path = "entry:sample:"+logstr+":value_log:start" 
    5695  
    5696         Make/O/T/N=1 tmpTW 
    5697         String groupName = "/entry/sample/"+logStr+"/value_log" 
    5698         String varName = "start" 
    5699         tmpTW[0] = str // 
    5700  
    5701         variable err 
    5702         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    5703         if(err) 
    5704                 Print "HDF write err = ",err 
    5705         endif 
    5706          
    5707         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    5708 //      err = V_KillNamedDataFolder(fname) 
    5709 //      if(err) 
    5710 //              Print "DataFolder kill err = ",err 
    5711 //      endif 
    5712                  
    5713         return(err) 
    5714 End 
    5715  
     6168// 
    57166169// TODO --  
    57176170Function V_writeLog_avgValue(fname,logStr,val) 
     
    57406193end 
    57416194 
     6195Function V_writeLog_avgValue_err(fname,logStr,val) 
     6196        String fname,logStr 
     6197        Variable val 
     6198         
     6199//      String path = "entry:sample:"+logstr+":value_log:average_value_error" 
     6200         
     6201        Make/O/D/N=1 wTmpWrite 
     6202//      Make/O/R/N=1 wTmpWrite 
     6203        String groupName = "/entry/sample/"+logStr+"/value_log" 
     6204        String varName = "average_value_error" 
     6205        wTmpWrite[0] = val 
     6206 
     6207        variable err 
     6208        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     6209        if(err) 
     6210                Print "HDF write err = ",err 
     6211        endif 
     6212        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6213//      err = V_KillNamedDataFolder(fname) 
     6214//      if(err) 
     6215//              Print "DataFolder kill err = ",err 
     6216//      endif 
     6217        return(err) 
     6218end 
     6219 
     6220Function V_writeLog_maximumValue(fname,logStr,val) 
     6221        String fname,logStr 
     6222        Variable val 
     6223         
     6224//      String path = "entry:sample:"+logstr+":value_log:maximum_value" 
     6225         
     6226        Make/O/D/N=1 wTmpWrite 
     6227//      Make/O/R/N=1 wTmpWrite 
     6228        String groupName = "/entry/sample/"+logStr+"/value_log" 
     6229        String varName = "maximum_value" 
     6230        wTmpWrite[0] = val 
     6231 
     6232        variable err 
     6233        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     6234        if(err) 
     6235                Print "HDF write err = ",err 
     6236        endif 
     6237        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6238//      err = V_KillNamedDataFolder(fname) 
     6239//      if(err) 
     6240//              Print "DataFolder kill err = ",err 
     6241//      endif 
     6242        return(err) 
     6243end 
     6244 
     6245Function V_writeLog_medianValue(fname,logStr,val) 
     6246        String fname,logStr 
     6247        Variable val 
     6248         
     6249//      String path = "entry:sample:"+logstr+":value_log:median_value" 
     6250         
     6251        Make/O/D/N=1 wTmpWrite 
     6252//      Make/O/R/N=1 wTmpWrite 
     6253        String groupName = "/entry/sample/"+logStr+"/value_log" 
     6254        String varName = "median_value" 
     6255        wTmpWrite[0] = val 
     6256 
     6257        variable err 
     6258        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     6259        if(err) 
     6260                Print "HDF write err = ",err 
     6261        endif 
     6262        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6263//      err = V_KillNamedDataFolder(fname) 
     6264//      if(err) 
     6265//              Print "DataFolder kill err = ",err 
     6266//      endif 
     6267        return(err) 
     6268end 
     6269 
     6270Function V_writeLog_minimumValue(fname,logStr,val) 
     6271        String fname,logStr 
     6272        Variable val 
     6273         
     6274//      String path = "entry:sample:"+logstr+":value_log:minimum_value" 
     6275         
     6276        Make/O/D/N=1 wTmpWrite 
     6277//      Make/O/R/N=1 wTmpWrite 
     6278        String groupName = "/entry/sample/"+logStr+"/value_log" 
     6279        String varName = "minimum_value" 
     6280        wTmpWrite[0] = val 
     6281 
     6282        variable err 
     6283        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     6284        if(err) 
     6285                Print "HDF write err = ",err 
     6286        endif 
     6287        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6288//      err = V_KillNamedDataFolder(fname) 
     6289//      if(err) 
     6290//              Print "DataFolder kill err = ",err 
     6291//      endif 
     6292        return(err) 
     6293end 
     6294 
     6295 
     6296 
    57426297// TODO -- this needs to be a WAVE reference 
     6298// be sure this gets written as "time", even though it is read in as "time0" 
    57436299Function V_writeLog_time(fname,logStr,inW) 
    57446300        String fname,logStr 
     
    58326388end 
    58336389 
     6390Function V_writeBackgroundFileName(fname,str) 
     6391        String fname,str 
     6392 
     6393//      String path = "entry:reduction:background_file_name"     
     6394 
     6395        Make/O/T/N=1 tmpTW 
     6396        String groupName = "/entry/reduction" 
     6397        String varName = "background_file_name" 
     6398        tmpTW[0] = str // 
     6399 
     6400        variable err 
     6401        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6402        if(err) 
     6403                Print "HDF write err = ",err 
     6404        endif 
     6405         
     6406        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6407//      err = V_KillNamedDataFolder(fname) 
     6408//      if(err) 
     6409//              Print "DataFolder kill err = ",err 
     6410//      endif 
     6411                 
     6412        return(err) 
     6413End 
     6414 
     6415 
    58346416// TODO -- needs to be a WAVE 
    58356417Function V_writeBoxCoordinates(fname,inW) 
     
    59376519End 
    59386520 
     6521Function V_writeEmptyBeamFileName(fname,str) 
     6522        String fname,str 
     6523 
     6524//      String path = "entry:reduction:empty_beam_file_name"     
     6525 
     6526        Make/O/T/N=1 tmpTW 
     6527        String groupName = "/entry/reduction" 
     6528        String varName = "empty_beam_file_name" 
     6529        tmpTW[0] = str // 
     6530 
     6531        variable err 
     6532        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6533        if(err) 
     6534                Print "HDF write err = ",err 
     6535        endif 
     6536         
     6537        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6538//      err = V_KillNamedDataFolder(fname) 
     6539//      if(err) 
     6540//              Print "DataFolder kill err = ",err 
     6541//      endif 
     6542                 
     6543        return(err) 
     6544End 
     6545 
     6546Function V_writeEmptyFileName(fname,str) 
     6547        String fname,str 
     6548 
     6549//      String path = "entry:reduction:empty_beam_file_name"     
     6550 
     6551        Make/O/T/N=1 tmpTW 
     6552        String groupName = "/entry/reduction" 
     6553        String varName = "empty_file_name" 
     6554        tmpTW[0] = str // 
     6555 
     6556        variable err 
     6557        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6558        if(err) 
     6559                Print "HDF write err = ",err 
     6560        endif 
     6561         
     6562        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6563//      err = V_KillNamedDataFolder(fname) 
     6564//      if(err) 
     6565//              Print "DataFolder kill err = ",err 
     6566//      endif 
     6567                 
     6568        return(err) 
     6569End 
     6570 
     6571Function V_writePolReduction_purpose(fname,str) 
     6572        String fname,str 
     6573 
     6574//      String path = "entry:reduction:file_purpose"     
     6575 
     6576        Make/O/T/N=1 tmpTW 
     6577        String groupName = "/entry/reduction" 
     6578        String varName = "file_purpose" 
     6579        tmpTW[0] = str // 
     6580 
     6581        variable err 
     6582        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6583        if(err) 
     6584                Print "HDF write err = ",err 
     6585        endif 
     6586         
     6587        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6588//      err = V_KillNamedDataFolder(fname) 
     6589//      if(err) 
     6590//              Print "DataFolder kill err = ",err 
     6591//      endif 
     6592                 
     6593        return(err) 
     6594End 
     6595 
     6596// TODO -- is this duplicated? 
     6597Function V_writeReduction_group_ID(fname,val) 
     6598        String fname 
     6599        Variable val 
     6600         
     6601//      String path = "entry:reduction:box_count_error"  
     6602         
     6603        Make/O/D/N=1 wTmpWrite 
     6604//      Make/O/R/N=1 wTmpWrite 
     6605        String groupName = "/entry/reduction" 
     6606        String varName = "group_id" 
     6607        wTmpWrite[0] = val 
     6608 
     6609        variable err 
     6610        err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     6611        if(err) 
     6612                Print "HDF write err = ",err 
     6613        endif 
     6614        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6615//      err = V_KillNamedDataFolder(fname) 
     6616//      if(err) 
     6617//              Print "DataFolder kill err = ",err 
     6618//      endif 
     6619        return(err) 
     6620end 
    59396621 
    59406622Function V_writeReductionIntent(fname,str) 
     
    59636645End 
    59646646 
     6647Function V_writeMaskFileName(fname,str) 
     6648        String fname,str 
     6649 
     6650//      String path = "entry:reduction:empty_beam_file_name"     
     6651 
     6652        Make/O/T/N=1 tmpTW 
     6653        String groupName = "/entry/reduction" 
     6654        String varName = "mask_file_name" 
     6655        tmpTW[0] = str // 
     6656 
     6657        variable err 
     6658        err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6659        if(err) 
     6660                Print "HDF write err = ",err 
     6661        endif 
     6662         
     6663        // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6664//      err = V_KillNamedDataFolder(fname) 
     6665//      if(err) 
     6666//              Print "DataFolder kill err = ",err 
     6667//      endif 
     6668                 
     6669        return(err) 
     6670End 
     6671 
     6672 
    59656673 
    59666674Function V_writeLogFileName(fname,str) 
     
    60406748End 
    60416749 
    6042 Function V_writeEmptyBeamFileName(fname,str) 
    6043         String fname,str 
    6044  
    6045 //      String path = "entry:reduction:empty_beam_file_name"     
    6046  
    6047         Make/O/T/N=1 tmpTW 
    6048         String groupName = "/entry/reduction" 
    6049         String varName = "empty_beam_file_name" 
    6050         tmpTW[0] = str // 
    6051  
    6052         variable err 
    6053         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    6054         if(err) 
    6055                 Print "HDF write err = ",err 
    6056         endif 
    6057          
    6058         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    6059 //      err = V_KillNamedDataFolder(fname) 
    6060 //      if(err) 
    6061 //              Print "DataFolder kill err = ",err 
    6062 //      endif 
    6063                  
    6064         return(err) 
    6065 End 
    6066  
    6067 Function V_writeEmptyFileName(fname,str) 
    6068         String fname,str 
    6069  
    6070 //      String path = "entry:reduction:empty_beam_file_name"     
    6071  
    6072         Make/O/T/N=1 tmpTW 
    6073         String groupName = "/entry/reduction" 
    6074         String varName = "empty_file_name" 
    6075         tmpTW[0] = str // 
    6076  
    6077         variable err 
    6078         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    6079         if(err) 
    6080                 Print "HDF write err = ",err 
    6081         endif 
    6082          
    6083         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    6084 //      err = V_KillNamedDataFolder(fname) 
    6085 //      if(err) 
    6086 //              Print "DataFolder kill err = ",err 
    6087 //      endif 
    6088                  
    6089         return(err) 
    6090 End 
    6091  
    6092 Function V_writeMaskFileName(fname,str) 
    6093         String fname,str 
    6094  
    6095 //      String path = "entry:reduction:empty_beam_file_name"     
    6096  
    6097         Make/O/T/N=1 tmpTW 
    6098         String groupName = "/entry/reduction" 
    6099         String varName = "mask_file_name" 
    6100         tmpTW[0] = str // 
    6101  
    6102         variable err 
    6103         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    6104         if(err) 
    6105                 Print "HDF write err = ",err 
    6106         endif 
    6107          
    6108         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    6109 //      err = V_KillNamedDataFolder(fname) 
    6110 //      if(err) 
    6111 //              Print "DataFolder kill err = ",err 
    6112 //      endif 
    6113                  
    6114         return(err) 
    6115 End 
    6116  
    6117 Function V_writeBackgroundFileName(fname,str) 
    6118         String fname,str 
    6119  
    6120 //      String path = "entry:reduction:empty_beam_file_name"     
    6121  
    6122         Make/O/T/N=1 tmpTW 
    6123         String groupName = "/entry/reduction" 
    6124         String varName = "background_file_name" 
    6125         tmpTW[0] = str // 
    6126  
    6127         variable err 
    6128         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    6129         if(err) 
    6130                 Print "HDF write err = ",err 
    6131         endif 
    6132          
    6133         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    6134 //      err = V_KillNamedDataFolder(fname) 
    6135 //      if(err) 
    6136 //              Print "DataFolder kill err = ",err 
    6137 //      endif 
    6138                  
    6139         return(err) 
    6140 End 
    61416750 
    61426751//whole detector transmission 
     
    61936802 
    61946803                         
    6195 /////                   pol_sans (data folder) 
    6196  
    6197 Function V_writePolSANS_cellName(fname,str) 
    6198         String fname,str 
    6199  
    6200 //      String path = "entry:reduction:pol_sans:cell_name"       
    6201  
    6202         Make/O/T/N=1 tmpTW 
    6203         String groupName = "/entry/reduction/pol_sans" 
    6204         String varName = "cell_name" 
    6205         tmpTW[0] = str // 
    6206  
    6207         variable err 
    6208         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    6209         if(err) 
    6210                 Print "HDF write err = ",err 
    6211         endif 
    6212          
    6213         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    6214 //      err = V_KillNamedDataFolder(fname) 
    6215 //      if(err) 
    6216 //              Print "DataFolder kill err = ",err 
    6217 //      endif 
    6218                  
    6219         return(err) 
    6220 End 
    6221  
    6222  
    6223 // TODO -- needs to be a WAVE 
    6224 // is this a text wave?? if it's mixed names + values, then what? 
    6225 Function V_writePolSANS_cellParams(fname,inW) 
    6226         String fname 
    6227         Wave inW 
    6228          
    6229 //      String path = "entry:reduction:pol_sans:cell_parameters" 
    6230                  
    6231         Duplicate/O inW wTmpWrite        
    6232 // then use redimension as needed to cast the wave to write to the specified type 
    6233 // see WaveType for the proper codes  
    6234 //      Redimension/T=() wTmpWrite 
    6235 // -- May also need to check the dimension(s) before writing (don't trust the input) 
    6236         String groupName = "/entry/reduction/pol_sans"   
    6237         String varName = "cell_parameters" 
    6238  
    6239         variable err 
    6240         err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
    6241         if(err) 
    6242                 Print "HDF write err = ",err 
    6243         endif 
    6244         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    6245 //      err = V_KillNamedDataFolder(fname) 
    6246 //      if(err) 
    6247 //              Print "DataFolder kill err = ",err 
    6248 //      endif 
    6249         return(err) 
    6250 end 
    6251  
    6252 Function V_writePolSANS_PolSANSPurpose(fname,str) 
    6253         String fname,str 
    6254  
    6255 //      String path = "entry:reduction:pol_sans:pol_sans_purpose"        
    6256  
    6257         Make/O/T/N=1 tmpTW 
    6258         String groupName = "/entry/reduction/pol_sans" 
    6259         String varName = "pol_sans_purpose" 
    6260         tmpTW[0] = str // 
    6261  
    6262         variable err 
    6263         err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
    6264         if(err) 
    6265                 Print "HDF write err = ",err 
    6266         endif 
    6267          
    6268         // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
    6269 //      err = V_KillNamedDataFolder(fname) 
    6270 //      if(err) 
    6271 //              Print "DataFolder kill err = ",err 
    6272 //      endif 
    6273                  
    6274         return(err) 
    6275 End 
     6804///////                 pol_sans (data folder) 
     6805// 
     6806//Function V_writePolSANS_cellName(fname,str) 
     6807//      String fname,str 
     6808// 
     6809////    String path = "entry:reduction:pol_sans:cell_name"       
     6810// 
     6811//      Make/O/T/N=1 tmpTW 
     6812//      String groupName = "/entry/reduction/pol_sans" 
     6813//      String varName = "cell_name" 
     6814//      tmpTW[0] = str // 
     6815// 
     6816//      variable err 
     6817//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6818//      if(err) 
     6819//              Print "HDF write err = ",err 
     6820//      endif 
     6821//       
     6822//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6823////    err = V_KillNamedDataFolder(fname) 
     6824////    if(err) 
     6825////            Print "DataFolder kill err = ",err 
     6826////    endif 
     6827//               
     6828//      return(err) 
     6829//End 
     6830// 
     6831// 
     6832//// TODO -- needs to be a WAVE 
     6833//// is this a text wave?? if it's mixed names + values, then what? 
     6834//Function V_writePolSANS_cellParams(fname,inW) 
     6835//      String fname 
     6836//      Wave inW 
     6837//       
     6838////    String path = "entry:reduction:pol_sans:cell_parameters" 
     6839//               
     6840//      Duplicate/O inW wTmpWrite        
     6841//// then use redimension as needed to cast the wave to write to the specified type 
     6842//// see WaveType for the proper codes  
     6843////    Redimension/T=() wTmpWrite 
     6844//// -- May also need to check the dimension(s) before writing (don't trust the input) 
     6845//      String groupName = "/entry/reduction/pol_sans"   
     6846//      String varName = "cell_parameters" 
     6847// 
     6848//      variable err 
     6849//      err = V_WriteWaveToHDF(fname, groupName, varName, wTmpWrite) 
     6850//      if(err) 
     6851//              Print "HDF write err = ",err 
     6852//      endif 
     6853//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6854////    err = V_KillNamedDataFolder(fname) 
     6855////    if(err) 
     6856////            Print "DataFolder kill err = ",err 
     6857////    endif 
     6858//      return(err) 
     6859//end 
     6860// 
     6861//Function V_writePolSANS_PolSANSPurpose(fname,str) 
     6862//      String fname,str 
     6863// 
     6864////    String path = "entry:reduction:pol_sans:pol_sans_purpose"        
     6865// 
     6866//      Make/O/T/N=1 tmpTW 
     6867//      String groupName = "/entry/reduction/pol_sans" 
     6868//      String varName = "pol_sans_purpose" 
     6869//      tmpTW[0] = str // 
     6870// 
     6871//      variable err 
     6872//      err = V_WriteTextWaveToHDF(fname, groupName, varName, tmpTW) 
     6873//      if(err) 
     6874//              Print "HDF write err = ",err 
     6875//      endif 
     6876//       
     6877//      // now be sure to kill the data folder to force a re-read of the data next time this file is read in 
     6878////    err = V_KillNamedDataFolder(fname) 
     6879////    if(err) 
     6880////            Print "DataFolder kill err = ",err 
     6881////    endif 
     6882//               
     6883//      return(err) 
     6884//End 
    62766885 
    62776886                                 
Note: See TracChangeset for help on using the changeset viewer.