Ignore:
Timestamp:
Feb 3, 2009 3:57:08 PM (14 years ago)
Author:
srkline
Message:

A large number of changes and fixes:

--168/169/170: panels and windows are now at least on-screen for all packages. Tested
with 1024x768 resolution.
-- closed ticket 176 which was a question about resampling data to generate error estimates
on fitted parameters. Useful for reflectometry, not needed for SANS.
--157: bug of low Q power law extrapolation in Invariant fixed by avoiding q==0
--178/180: Tr/Tw? notification in USANS. log/lin checkbox for display.
--167: saveData checkbox for USANS not behaving well. turns off/on better now.
--197: changed all (?) 1D writing routines to enforce 26 characters as the maximum length
to make sure that file loading will never exceed 31 characters

-- lots of changes to MonteCarlo? and SASCALC

  • SASCALC now enforces *exact* lens conditions, rather than a close approximation
  • improved MonteCarlo? interface panel
  • added writer for simlulated VAX binary data file
  • can save 2D as ABS or raw counts
  • can freeze w/no offset
Location:
sans/Dev/trunk/NCNR_User_Procedures/Reduction
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • sans/Dev/trunk/NCNR_User_Procedures/Reduction/SANS/MultScatter_MonteCarlo_2D.ipf

    r465 r472  
    5656// - a number of models are now found to be ill-behaved when q=1e-10. Then the random deviate calculation blows up. 
    5757//   a warning has been added - but some models need a proper limiting value, and some (power-law) are simply unuseable 
    58 //   unless something else can be done. 
     58//   unless something else can be done. Using a log-spacing of points doesn't seem to help, and it introduces a lot of 
     59//   other problems. Not the way to go. 
    5960// - if the MC gags on a simulation, it often gets "stuck" and can't do the normal calculation from the model, which it 
    6061//   should always default to... 
     
    7071        // does nothing in the Igor code 
    7172        Duplicate/O results retWave 
    72         //results[0] = -1*(datetime) 
    7373 
    7474        Variable NNeutron=inputWave[0] 
     
    8181         
    8282        variable mt= ThreadGroupCreate(nthreads) 
     83        NVAR gInitTime = root:Packages:NIST:SAS:gRanDateTime            //time that SASCALC was started 
     84 
    8385         
    8486        inputWave[0] = NNeutron/nthreads                //split up the number of neutrons 
     
    9395                Duplicate/O inputWave $("inputWave"+num2istr(i)) 
    9496                Duplicate/O ran_dev $("ran_dev"+num2istr(i)) 
    95                  
     97                                 
    9698                // ?? I need explicit wave references? 
    9799                // maybe I need to have everything in separate data folders - bu tI haven't tried that. seems like a reach. 
     
    99101                if(i==0) 
    100102                        WAVE inputWave0,ran_dev0,nt0,j10,j20,nn0,linear_data0,retWave0 
    101                         retWave0[0] = -1*datetime               //to initialize ran3 
     103                        retWave0 = 0            //clear the return wave 
     104                        retWave0[0] = -1*(datetime-gInitTime)           //to initialize ran3 
    102105                        ThreadStart mt,i,Monte_SANS_W1(inputWave0,ran_dev0,nt0,j10,j20,nn0,linear_data0,retWave0) 
    103106                        Print "started thread 0" 
     
    105108                if(i==1) 
    106109                        WAVE inputWave1,ran_dev1,nt1,j11,j21,nn1,linear_data1,retWave1 
    107                         //retWave1[0] = -1*datetime             //to initialize ran3 
     110                        retWave1 = 0                    //clear the return wave 
     111                        retWave1[0] = -1*(datetime-gInitTime)           //to initialize ran1 
    108112                        ThreadStart mt,i,Monte_SANS_W2(inputWave1,ran_dev1,nt1,j11,j21,nn1,linear_data1,retWave1) 
    109113                        Print "started thread 1" 
     
    180184 
    181185// worker function for threads, does nothing except switch between XOP and Igor versions 
     186// 
     187// uses ran3 
    182188ThreadSafe Function Monte_SANS_W1(inputWave,ran_dev,nt,j1,j2,nn,linear_data,results) 
    183189        WAVE inputWave,ran_dev,nt,j1,j2,nn,linear_data,results 
     
    191197        return (0) 
    192198End 
     199 
    193200// worker function for threads, does nothing except switch between XOP and Igor versions 
     201// 
     202// uses ran1 
    194203ThreadSafe Function Monte_SANS_W2(inputWave,ran_dev,nt,j1,j2,nn,linear_data,results) 
    195204        WAVE inputWave,ran_dev,nt,j1,j2,nn,linear_data,results 
     
    569578        qu = 4*pi/lam            
    570579         
    571 //      Make/O/N=(nPts_ran)/D root:Packages:NIST:SAS:Gq,root:Packages:NIST:SAS:xw               // if these waves are 1000 pts, the results are "pixelated" 
    572 //      WAVE Gq = root:Packages:NIST:SAS:gQ 
    573 //      WAVE xw = root:Packages:NIST:SAS:xw 
    574  
    575580// hard-wired into the Simulation directory rather than the SAS folder. 
    576581// plotting resolution-smeared models won't work any other way 
     
    578583        WAVE Gq = root:Simulation:gQ 
    579584        WAVE xw = root:Simulation:xw 
    580         SetScale/I x (0+1e-6),qu*(1-1e-10),"", Gq,xw                    //don't start at zero or run up all the way to qu to avoid numerical errors 
    581  
    582 /// 
     585        SetScale/I x (0+1e-4),qu*(1-1e-10),"", Gq,xw                    //don't start at zero or run up all the way to qu to avoid numerical errors 
     586 
    583587/// if all of the coefficients are well-behaved, then the last point is the background 
    584588// and I can set it to zero here (only for the calculation) 
     
    593597        Gq = Gq*sin(2*asin(x/qu))/sqrt(1-(x/qu))                        // exact 
    594598        // 
     599        // 
    595600        Integrate/METH=1 Gq/D=Gq_INT 
    596601         
     
    605610End 
    606611 
    607  
     612// returns the random deviate as a wave 
     613// and the total SAS cross-section [1/cm] sig_sas 
     614// 
     615// uses a log spacing of x for better coverage 
     616// downside is that it doesn't use built-in integrate, which is automatically cumulative 
     617// 
     618// --- Currently does not work - since the usage of the random deviate in the MC routine is based on the  
     619// wave properties of ran_dev, that is it must have the proper scaling and be equally spaced. 
     620// 
     621// -- not really sure that this will solve any of the problems with some functions (notably those with power-laws) 
     622// giving unreasonably large SAS cross sections. (>>10) 
     623// 
     624Function CalculateRandomDeviate_log(func,coef,lam,outWave,SASxs) 
     625        FUNCREF SANSModelAAO_MCproto func 
     626        WAVE coef 
     627        Variable lam 
     628        String outWave 
     629        Variable &SASxs 
     630 
     631        Variable nPts_ran=1000,qu,qmin,ii 
     632        qmin=1e-5 
     633        qu = 4*pi/lam            
     634 
     635// hard-wired into the Simulation directory rather than the SAS folder. 
     636// plotting resolution-smeared models won't work any other way 
     637        Make/O/N=(nPts_ran)/D root:Simulation:Gq,root:Simulation:xw             // if these waves are 1000 pts, the results are "pixelated" 
     638        WAVE Gq = root:Simulation:gQ 
     639        WAVE xw = root:Simulation:xw 
     640//      SetScale/I x (0+1e-4),qu*(1-1e-10),"", Gq,xw                    //don't start at zero or run up all the way to qu to avoid numerical errors 
     641        xw =  alog(log(qmin) + x*((log(qu)-log(qmin))/nPts_ran)) 
     642 
     643/// if all of the coefficients are well-behaved, then the last point is the background 
     644// and I can set it to zero here (only for the calculation) 
     645        Duplicate/O coef,tmp_coef 
     646        Variable num=numpnts(coef) 
     647        tmp_coef[num-1] = 0 
     648         
     649        func(tmp_coef,Gq,xw)                                                                    //call as AAO 
     650        Gq = Gq*sin(2*asin(xw/qu))/sqrt(1-(xw/qu))                      // exact 
     651 
     652         
     653        Duplicate/O Gq Gq_INT 
     654        Gq_INT = 0 
     655        for(ii=0;ii<nPts_ran;ii+=1) 
     656                Gq_INT[ii] = AreaXY(xw,Gq,qmin,xw[ii]) 
     657        endfor 
     658         
     659        SASxs = lam*Gq_INT[nPts_ran-1] 
     660         
     661        Gq_INT /= Gq_INT[nPts_ran-1] 
     662         
     663        Duplicate/O Gq_INT $outWave 
     664 
     665        return(0) 
     666End 
    608667 
    609668ThreadSafe Function FindPixel(testQ,testPhi,lam,sdd,pixSize,xCtr,yCtr,xPixel,yPixel) 
     
    802861 
    803862// globals are initialized in SASCALC.ipf 
     863// coordinates if I make this part of the panel - but this breaks other things... 
     864// 
     865//Proc MC_SASCALC() 
     866////    PauseUpdate; Silent 1           // building window... 
     867// 
     868////    NewPanel /W=(92,556,390,1028)/K=1 as "SANS Simulator" 
     869//      SetVariable MC_setvar0,pos={491,73},size={144,15},bodyWidth=80,title="# of neutrons" 
     870//      SetVariable MC_setvar0,format="%5.4g" 
     871//      SetVariable MC_setvar0,limits={-inf,inf,100},value= root:Packages:NIST:SAS:gImon 
     872//      SetVariable MC_setvar0_1,pos={491,119},size={131,15},bodyWidth=60,title="Thickness (cm)" 
     873//      SetVariable MC_setvar0_1,limits={-inf,inf,0.1},value= root:Packages:NIST:SAS:gThick 
     874//      SetVariable MC_setvar0_2,pos={491,96},size={149,15},bodyWidth=60,title="Incoherent XS (cm)" 
     875//      SetVariable MC_setvar0_2,limits={-inf,inf,0.1},value= root:Packages:NIST:SAS:gSig_incoh 
     876//      SetVariable MC_setvar0_3,pos={491,142},size={150,15},bodyWidth=60,title="Sample Radius (cm)" 
     877//      SetVariable MC_setvar0_3,limits={-inf,inf,0.1},value= root:Packages:NIST:SAS:gR2 
     878//      PopupMenu MC_popup0,pos={476,13},size={165,20},proc=MC_ModelPopMenuProc,title="Model Function" 
     879//      PopupMenu MC_popup0,mode=1,value= #"MC_FunctionPopupList()" 
     880//      Button MC_button0,pos={480,181},size={130,20},proc=MC_DoItButtonProc,title="Do MC Simulation" 
     881//      Button MC_button1,pos={644,181},size={80,20},proc=MC_Display2DButtonProc,title="Show 2D" 
     882//      SetVariable setvar0_3,pos={568,484},size={50,20},disable=1 
     883//      GroupBox group0,pos={478,42},size={267,130},title="Monte Carlo" 
     884//      SetVariable cntVar,pos={653,73},size={80,15},proc=CountTimeSetVarProc,title="time(s)" 
     885//      SetVariable cntVar,format="%d" 
     886//      SetVariable cntVar,limits={1,10,1},value= root:Packages:NIST:SAS:gCntTime 
     887//       
     888//      String fldrSav0= GetDataFolder(1) 
     889//      SetDataFolder root:Packages:NIST:SAS: 
     890//      Edit/W=(476,217,746,450)/HOST=#  results_desc,results 
     891//      ModifyTable format(Point)=1,width(Point)=0,width(results_desc)=150 
     892//      SetDataFolder fldrSav0 
     893//      RenameWindow #,T_results 
     894//      SetActiveSubwindow ## 
     895EndMacro 
     896 
     897// as a stand-alone panel, extra control bar  (right) and subwindow implementations don't work right  
     898// for various reasons... 
    804899Window MC_SASCALC() : Panel 
    805900        PauseUpdate; Silent 1           // building window... 
    806         NewPanel /W=(92,556,390,1028)/K=1 as "SANS Simulator" 
     901        NewPanel /W=(92,556,713,818)/K=1 as "SANS Simulator" 
    807902        SetVariable MC_setvar0,pos={28,73},size={144,15},bodyWidth=80,title="# of neutrons" 
    808903        SetVariable MC_setvar0,format="%5.4g" 
     
    817912        PopupMenu MC_popup0,mode=1,value= #"MC_FunctionPopupList()" 
    818913        Button MC_button0,pos={17,181},size={130,20},proc=MC_DoItButtonProc,title="Do MC Simulation" 
    819         Button MC_button1,pos={181,181},size={80,20},proc=MC_Display2DButtonProc,title="Show 2D" 
     914        Button MC_button0,fColor=(3,52428,1) 
     915        Button MC_button1,pos={17,208},size={80,20},proc=MC_Display2DButtonProc,title="Show 2D" 
    820916        SetVariable setvar0_3,pos={105,484},size={50,20},disable=1 
    821917        GroupBox group0,pos={15,42},size={267,130},title="Monte Carlo" 
    822918        SetVariable cntVar,pos={190,73},size={80,15},proc=CountTimeSetVarProc,title="time(s)" 
    823919        SetVariable cntVar,format="%d" 
    824         SetVariable cntVar,limits={1,10,1},value= root:Packages:NIST:SAS:gCntTime 
     920        SetVariable cntVar,limits={1,60,1},value= root:Packages:NIST:SAS:gCntTime 
     921        Button MC_button2,pos={17,234},size={100,20},proc=SaveAsVAXButtonProc,title="Save 2D VAX" 
     922        CheckBox check0,pos={216,180},size={68,14},title="Raw counts",variable = root:Packages:NIST:SAS:gRawCounts 
     923        CheckBox check0_1,pos={216,199},size={60,14},title="Yes Offset",variable= root:Packages:NIST:SAS:gDoTraceOffset 
    825924         
    826925        String fldrSav0= GetDataFolder(1) 
    827926        SetDataFolder root:Packages:NIST:SAS: 
    828         Edit/W=(13,217,283,450)/HOST=#  results_desc,results 
     927        Edit/W=(344,23,606,248)/HOST=#  results_desc,results 
    829928        ModifyTable format(Point)=1,width(Point)=0,width(results_desc)=150 
    830929        SetDataFolder fldrSav0 
     
    832931        SetActiveSubwindow ## 
    833932EndMacro 
    834  
    835933 
    836934Function CountTimeSetVarProc(sva) : SetVariableControl 
     
    9561054End 
    9571055 
     1056// writes out a VAX binary data file 
     1057// automatically generates a name 
     1058// will prompt for the sample label 
     1059// 
     1060Function SaveAsVAXButtonProc(ctrlName) : ButtonControl 
     1061        String ctrlName 
     1062 
     1063        WriteVAXData("SAS","",0) 
     1064End 
     1065 
     1066 
    9581067 
    9591068 
  • sans/Dev/trunk/NCNR_User_Procedures/Reduction/SANS/NCNR_DataReadWrite.ipf

    r425 r472  
    351351         
    352352        //clean up - get rid of w = $"root:Packages:NIST:RAW:tempGBWave0" 
    353         KillWaves/Z w 
     353//      KillWaves/Z w 
    354354         
    355355        //return the data folder to root 
     
    12871287        Variable refnum 
    12881288        Open/A/T="????TEXT" refnum as fname      //Open for writing! Move to EOF before closing! 
    1289         FSetPos refnum,31 
     1289        FSetPos refnum,start 
    12901290        FBinWrite/B=3/F=3 refnum, val      //write a 4-byte integer 
    12911291        //move to the end of the file before closing 
     
    17721772        return(0) 
    17731773End 
     1774 
     1775 
     1776// given a data folder, write out the corresponding VAX binary data file. 
     1777// 
     1778// I don't think that I can generate a STRUCT and then lay that down - since the 
     1779// VAX FP format has to be duplicated with a write/read/flip/re-write dance... 
     1780// 
     1781// seems to work correctly byte for byte 
     1782// compression has bee implmented also, for complete replication of the format (n>32767 in a cell) 
     1783// 
     1784// SRK 29JAN09 
     1785// 
     1786// other functions needed: 
     1787// 
     1788// 
     1789// one to generate a fake data file name, and put the matching name in the data header 
     1790// !! must fake the Annn suffix too! this is used... 
     1791// use a prefix, keep a run number, initials SIM, and alpha as before (start randomly, don't bother changing?) 
     1792// 
     1793// for right now, keep a run number, and generate 
     1794// PREFIXnnn.SA2_SIM_Annn 
     1795// also, start the index @ 100 to avoid leading zeros (although I have the functions available) 
     1796 
     1797// one to generate the date/time string in VAX format, right # characters// Print Secs2Time(DateTime,3)                         // Prints 13:07:29 
     1798// Print Secs2Time(DateTime,3)                          // Prints 13:07:29 
     1799//      Print Secs2Date(DateTime,-2)            // 1993-03-14                   //this call is independent of System date/time!// 
     1800// 
     1801// for now, 20 characters 01-JAN-2009 12:12:12 
     1802// 
     1803 
     1804// simulation should call as ("SAS","",0) to bypass the dialog, and to fill the header 
     1805// this could be modified in the future to be more generic 
     1806// 
     1807/// 
     1808Function WriteVAXData(type,fullpath,dialog) 
     1809        String type,fullpath 
     1810        Variable dialog         //=1 will present dialog for name 
     1811         
     1812        String destStr="" 
     1813        Variable refNum,ii,val,err 
     1814         
     1815         
     1816        destStr = "root:Packages:NIST:"+type 
     1817         
     1818        SetDataFolder $destStr 
     1819        WAVE intw=integersRead 
     1820        WAVE rw=realsRead 
     1821        WAVE/T textw=textRead 
     1822        WAVE data=linear_data 
     1823         
     1824        //check each wave 
     1825        If(!(WaveExists(intw))) 
     1826                Abort "intw DNExist WriteVAXData()" 
     1827        Endif 
     1828        If(!(WaveExists(rw))) 
     1829                Abort "rw DNExist WriteVAXData()" 
     1830        Endif 
     1831        If(!(WaveExists(textw))) 
     1832                Abort "textw DNExist WriteVAXData()" 
     1833        Endif 
     1834        If(!(WaveExists(data))) 
     1835                Abort "linear_data DNExist WriteVAXData()" 
     1836        Endif 
     1837         
     1838         
     1839//      if(dialog) 
     1840//              PathInfo/S catPathName 
     1841//              fullPath = DoSaveFileDialog("Save data as") 
     1842//              If(cmpstr(fullPath,"")==0) 
     1843//                      //user cancel, don't write out a file 
     1844//                      Close/A 
     1845//                      Abort "no data file was written" 
     1846//              Endif 
     1847//              //Print "dialog fullpath = ",fullpath 
     1848//      Endif 
     1849         
     1850        // save to home, or get out 
     1851        // 
     1852        PathInfo home 
     1853        if(V_flag       == 0) 
     1854                Abort "no save path defined. Save the experiment to generate a home path" 
     1855        endif 
     1856         
     1857        fullPath = S_path               //not the full path yet, still need the name, after the header is filled 
     1858         
     1859         
     1860        Make/O/B/U/N=33316 tmpFile              //unsigned integers for a blank data file 
     1861        tmpFile=0 
     1862         
     1863        Make/O/W/N=16401 dataWRecMarkers 
     1864        AddRecordMarkers(data,dataWRecMarkers) 
     1865         
     1866        // need to re-compress?? maybe never a problem, but should be done for the odd case 
     1867        dataWRecMarkers = CompressI4toI2(dataWRecMarkers)               //unless a pixel value is > 32767, the same values are returned 
     1868         
     1869        // fill the last bits of the header information 
     1870        err = SimulationVAXHeader(type) 
     1871        if (err == -1) 
     1872                Abort "no sample label entered - no file written"                       // User did not fill in header correctly/completely 
     1873        endif 
     1874        fullPath = fullPath + textW[0] 
     1875         
     1876        // lay down a blank file 
     1877        Open refNum as fullpath 
     1878                FBinWrite refNum,tmpFile                        //file is the right size, but all zeroes 
     1879        Close refNum 
     1880         
     1881        // fill up the header 
     1882        // text values 
     1883        // elements of textW are already the correct length set by the read, but just make sure 
     1884        String str 
     1885         
     1886        if(strlen(textw[0])>21) 
     1887                textw[0] = (textw[0])[0,20] 
     1888        endif 
     1889        if(strlen(textw[1])>20) 
     1890                textw[1] = (textw[1])[0,19] 
     1891        endif 
     1892        if(strlen(textw[2])>3) 
     1893                textw[2] = (textw[2])[0,2] 
     1894        endif 
     1895        if(strlen(textw[3])>11) 
     1896                textw[3] = (textw[3])[0,10] 
     1897        endif 
     1898        if(strlen(textw[4])>1) 
     1899                textw[4] = (textw[4])[0] 
     1900        endif 
     1901        if(strlen(textw[5])>8) 
     1902                textw[5] = (textw[5])[0,7] 
     1903        endif 
     1904        if(strlen(textw[6])>60) 
     1905                textw[6] = (textw[6])[0,59] 
     1906        endif 
     1907        if(strlen(textw[7])>6) 
     1908                textw[7] = (textw[7])[0,5] 
     1909        endif 
     1910        if(strlen(textw[8])>6) 
     1911                textw[8] = (textw[8])[0,5] 
     1912        endif 
     1913        if(strlen(textw[9])>6) 
     1914                textw[9] = (textw[9])[0,5] 
     1915        endif 
     1916        if(strlen(textw[10])>42) 
     1917                textw[10] = (textw[10])[0,41] 
     1918        endif    
     1919         
     1920        ii=0 
     1921        Open/A/T="????TEXT" refnum as fullpath      //Open for writing! Move to EOF before closing! 
     1922                str = textW[ii] 
     1923                FSetPos refnum,2                                                        ////file name 
     1924                FBinWrite/F=0 refnum, str      //native object format (character) 
     1925                ii+=1 
     1926                str = textW[ii] 
     1927                FSetPos refnum,55                                                       ////date/time 
     1928                FBinWrite/F=0 refnum, str 
     1929                ii+=1 
     1930                str = textW[ii] 
     1931                FSetPos refnum,75                                                       ////type 
     1932                FBinWrite/F=0 refnum, str 
     1933                ii+=1 
     1934                str = textW[ii] 
     1935                FSetPos refnum,78                                               ////def dir 
     1936                FBinWrite/F=0 refnum, str 
     1937                ii+=1 
     1938                str = textW[ii] 
     1939                FSetPos refnum,89                                               ////mode 
     1940                FBinWrite/F=0 refnum, str 
     1941                ii+=1 
     1942                str = textW[ii] 
     1943                FSetPos refnum,90                                               ////reserve 
     1944                FBinWrite/F=0 refnum, str 
     1945                ii+=1 
     1946                str = textW[ii] 
     1947                FSetPos refnum,98                                               ////@98, sample label 
     1948                FBinWrite/F=0 refnum, str 
     1949                ii+=1 
     1950                str = textW[ii] 
     1951                FSetPos refnum,202                                              //// T units 
     1952                FBinWrite/F=0 refnum, str 
     1953                ii+=1 
     1954                str = textW[ii] 
     1955                FSetPos refnum,208                                              //// F units 
     1956                FBinWrite/F=0 refnum, str 
     1957                ii+=1 
     1958                str = textW[ii] 
     1959                FSetPos refnum,214                                              ////det type 
     1960                FBinWrite/F=0 refnum, str 
     1961                ii+=1 
     1962                str = textW[ii] 
     1963                FSetPos refnum,404                                              ////reserve 
     1964                FBinWrite/F=0 refnum, str 
     1965         
     1966                //move to the end of the file before closing 
     1967                FStatus refnum 
     1968                FSetPos refnum,V_logEOF 
     1969        Close refnum 
     1970         
     1971         
     1972        // integer values (4 bytes) 
     1973        ii=0 
     1974        Open/A/T="????TEXT" refnum as fullpath      //Open for writing! Move to EOF before closing! 
     1975                val = intw[ii] 
     1976                FSetPos refnum,23                                                       //nprefactors 
     1977                FBinWrite/B=3/F=3 refnum, val      //write a 4-byte integer 
     1978                ii+=1 
     1979                val=intw[ii] 
     1980                FSetPos refnum,27                                                       //ctime 
     1981                FBinWrite/B=3/F=3 refnum, val 
     1982                ii+=1 
     1983                val=intw[ii] 
     1984                FSetPos refnum,31                                                       //rtime 
     1985                FBinWrite/B=3/F=3 refnum, val 
     1986                ii+=1 
     1987                val=intw[ii] 
     1988                FSetPos refnum,35                                                       //numruns 
     1989                FBinWrite/B=3/F=3 refnum, val 
     1990                ii+=1 
     1991                val=intw[ii] 
     1992                FSetPos refnum,174                                                      //table 
     1993                FBinWrite/B=3/F=3 refnum, val 
     1994                ii+=1 
     1995                val=intw[ii] 
     1996                FSetPos refnum,178                                                      //holder 
     1997                FBinWrite/B=3/F=3 refnum, val 
     1998                ii+=1 
     1999                val=intw[ii] 
     2000                FSetPos refnum,182                                                      //blank 
     2001                FBinWrite/B=3/F=3 refnum, val 
     2002                ii+=1 
     2003                val=intw[ii] 
     2004                FSetPos refnum,194                                                      //tctrlr 
     2005                FBinWrite/B=3/F=3 refnum, val 
     2006                ii+=1 
     2007                val=intw[ii] 
     2008                FSetPos refnum,198                                                      //magnet 
     2009                FBinWrite/B=3/F=3 refnum, val 
     2010                ii+=1 
     2011                val=intw[ii] 
     2012                FSetPos refnum,244                                                      //det num 
     2013                FBinWrite/B=3/F=3 refnum, val 
     2014                ii+=1 
     2015                val=intw[ii] 
     2016                FSetPos refnum,248                                                      //det spacer 
     2017                FBinWrite/B=3/F=3 refnum, val 
     2018                ii+=1 
     2019                val=intw[ii] 
     2020                FSetPos refnum,308                                                      //tslice mult 
     2021                FBinWrite/B=3/F=3 refnum, val 
     2022                ii+=1 
     2023                val=intw[ii] 
     2024                FSetPos refnum,312                                                      //tsclice ltslice 
     2025                FBinWrite/B=3/F=3 refnum, val 
     2026                ii+=1 
     2027                val=intw[ii] 
     2028                FSetPos refnum,332                                                      //extra 
     2029                FBinWrite/B=3/F=3 refnum, val 
     2030                ii+=1 
     2031                val=intw[ii] 
     2032                FSetPos refnum,336                                                      //reserve 
     2033                FBinWrite/B=3/F=3 refnum, val 
     2034                ii+=1 
     2035                val=intw[ii] 
     2036                FSetPos refnum,376                                                      //blank1 
     2037                FBinWrite/B=3/F=3 refnum, val 
     2038                ii+=1 
     2039                val=intw[ii] 
     2040                FSetPos refnum,380                                                      //blank2 
     2041                FBinWrite/B=3/F=3 refnum, val 
     2042                ii+=1 
     2043                val=intw[ii] 
     2044                FSetPos refnum,384                                                      //blank3 
     2045                FBinWrite/B=3/F=3 refnum, val 
     2046                ii+=1 
     2047                val=intw[ii] 
     2048                FSetPos refnum,458                                                      //spacer 
     2049                FBinWrite/B=3/F=3 refnum, val 
     2050                ii+=1 
     2051                val=intw[ii] 
     2052                FSetPos refnum,478                                                      //box x1 
     2053                FBinWrite/B=3/F=3 refnum, val 
     2054                ii+=1 
     2055                val=intw[ii] 
     2056                FSetPos refnum,482                                                      //box x2 
     2057                FBinWrite/B=3/F=3 refnum, val 
     2058                ii+=1 
     2059                val=intw[ii] 
     2060                FSetPos refnum,486                                                      //box y1 
     2061                FBinWrite/B=3/F=3 refnum, val 
     2062                ii+=1 
     2063                val=intw[ii] 
     2064                FSetPos refnum,490                                                      //box y2 
     2065                FBinWrite/B=3/F=3 refnum, val 
     2066                 
     2067                //move to the end of the file before closing 
     2068                FStatus refnum 
     2069                FSetPos refnum,V_logEOF 
     2070        Close refnum 
     2071         
     2072                 
     2073        //VAX 4-byte FP values. No choice here but to write/read/re-write to get  
     2074        // the proper format. there are 52! values to write 
     2075        //WriteVAXReal(fullpath,rw[n],start) 
     2076        // [0] 
     2077        WriteVAXReal(fullpath,rw[0],39) 
     2078        WriteVAXReal(fullpath,rw[1],43) 
     2079        WriteVAXReal(fullpath,rw[2],47) 
     2080        WriteVAXReal(fullpath,rw[3],51) 
     2081        WriteVAXReal(fullpath,rw[4],158) 
     2082        WriteVAXReal(fullpath,rw[5],162) 
     2083        WriteVAXReal(fullpath,rw[6],166) 
     2084        WriteVAXReal(fullpath,rw[7],170) 
     2085        WriteVAXReal(fullpath,rw[8],186) 
     2086        WriteVAXReal(fullpath,rw[9],190) 
     2087        // [10] 
     2088        WriteVAXReal(fullpath,rw[10],220) 
     2089        WriteVAXReal(fullpath,rw[11],224) 
     2090        WriteVAXReal(fullpath,rw[12],228) 
     2091        WriteVAXReal(fullpath,rw[13],232) 
     2092        WriteVAXReal(fullpath,rw[14],236) 
     2093        WriteVAXReal(fullpath,rw[15],240) 
     2094        WriteVAXReal(fullpath,rw[16],252) 
     2095        WriteVAXReal(fullpath,rw[17],256) 
     2096        WriteVAXReal(fullpath,rw[18],260) 
     2097        WriteVAXReal(fullpath,rw[19],264) 
     2098        // [20] 
     2099        WriteVAXReal(fullpath,rw[20],268) 
     2100        WriteVAXReal(fullpath,rw[21],272) 
     2101        WriteVAXReal(fullpath,rw[22],276) 
     2102        WriteVAXReal(fullpath,rw[23],280) 
     2103        WriteVAXReal(fullpath,rw[24],284) 
     2104        WriteVAXReal(fullpath,rw[25],288) 
     2105        WriteVAXReal(fullpath,rw[26],292) 
     2106        WriteVAXReal(fullpath,rw[27],296) 
     2107        WriteVAXReal(fullpath,rw[28],300) 
     2108        WriteVAXReal(fullpath,rw[29],320) 
     2109        // [30] 
     2110        WriteVAXReal(fullpath,rw[30],324) 
     2111        WriteVAXReal(fullpath,rw[31],328) 
     2112        WriteVAXReal(fullpath,rw[32],348) 
     2113        WriteVAXReal(fullpath,rw[33],352) 
     2114        WriteVAXReal(fullpath,rw[34],356) 
     2115        WriteVAXReal(fullpath,rw[35],360) 
     2116        WriteVAXReal(fullpath,rw[36],364) 
     2117        WriteVAXReal(fullpath,rw[37],368) 
     2118        WriteVAXReal(fullpath,rw[38],372) 
     2119        WriteVAXReal(fullpath,rw[39],388) 
     2120        // [40] 
     2121        WriteVAXReal(fullpath,rw[40],392) 
     2122        WriteVAXReal(fullpath,rw[41],396) 
     2123        WriteVAXReal(fullpath,rw[42],400) 
     2124        WriteVAXReal(fullpath,rw[43],450) 
     2125        WriteVAXReal(fullpath,rw[44],454) 
     2126        WriteVAXReal(fullpath,rw[45],470) 
     2127        WriteVAXReal(fullpath,rw[46],474) 
     2128        WriteVAXReal(fullpath,rw[47],494) 
     2129        WriteVAXReal(fullpath,rw[48],498) 
     2130        WriteVAXReal(fullpath,rw[49],502) 
     2131        // [50] 
     2132        WriteVAXReal(fullpath,rw[50],506) 
     2133        WriteVAXReal(fullpath,rw[51],510) 
     2134         
     2135         
     2136        // write out the data 
     2137        Open refNum as fullpath 
     2138                FSetPos refnum,514                                      //  OK 
     2139                FBinWrite/F=2/B=3 refNum,dataWRecMarkers                //don't trust the native format 
     2140                FStatus refNum 
     2141                FSetPos refNum,V_logEOF 
     2142        Close refNum 
     2143         
     2144        // all done 
     2145        Killwaves/Z tmpFile,dataWRecMarkers 
     2146         
     2147        Print "Saved VAX binary data as:  ",textW[0] 
     2148        SetDatafolder root: 
     2149        return(0) 
     2150End 
     2151 
     2152 
     2153Function AddRecordMarkers(in,out) 
     2154        Wave in,out 
     2155         
     2156        Variable skip,ii 
     2157 
     2158//      Duplicate/O in,out 
     2159//      Redimension/N=16401 out 
     2160 
     2161        out=0 
     2162         
     2163        ii=0 
     2164        skip=0 
     2165        out[ii] = 1 
     2166        ii+=1 
     2167        do 
     2168                if(mod(ii+skip,1022)==0) 
     2169                        out[ii+skip] = 0                //999999 
     2170                        skip+=1                 //increment AFTER filling the current marker 
     2171                endif 
     2172                out[ii+skip] = in[ii-1] 
     2173                ii+=1 
     2174        while(ii<=16384) 
     2175         
     2176         
     2177        return(0) 
     2178End 
     2179 
     2180 
     2181 
     2182 
     2183//        INTEGER*2 FUNCTION I4ToI2(I4) 
     2184//C 
     2185//C       Original author : Jim Rhyne 
     2186//C       Modified by     : Frank Chen 09/26/90 
     2187//C 
     2188//C       I4ToI2 = I4,                            I4 in [0,32767] 
     2189//C       I4ToI2 = -777,                          I4 in (2767000,...) 
     2190//C       I4ToI2 mapped to -13277 to -32768,      otherwise 
     2191//C 
     2192//C       the mapped values [-776,-1] and [-13276,-778] are not used 
     2193//C 
     2194//C       I4max should be 2768499, this value will maps to -32768 
     2195//C       and mantissa should be compared  using  
     2196//C               IF (R4 .GE. IPW) 
     2197//C       instead of 
     2198//C               IF (R4 .GT. (IPW - 1.0)) 
     2199//C 
     2200// 
     2201// 
     2202//C       I4      :       input I*4 
     2203//C       R4      :       temperory real number storage 
     2204//C       IPW     :       IPW = IB ** ND 
     2205//C       NPW     :       number of power 
     2206//C       IB      :       Base value 
     2207//C       ND      :       Number of precision digits 
     2208//C       I4max   :       max data value w/ some error 
     2209//C       I2max   :       max data value w/o error 
     2210//C       Error   :       when data value > I4max 
     2211//C 
     2212//        INTEGER*4       I4 
     2213//        INTEGER*4       NPW 
     2214//        REAL*4          R4 
     2215//        INTEGER*4       IPW 
     2216//        INTEGER*4       IB      /10/ 
     2217//        INTEGER*4       ND      /4/ 
     2218//        INTEGER*4       I4max   /2767000/ 
     2219//        INTEGER*4       I2max   /32767/ 
     2220//        INTEGER*4       Error   /-777/ 
     2221// 
     2222Function CompressI4toI2(i4) 
     2223        Variable i4 
     2224 
     2225        Variable npw,ipw,ib,nd,i4max,i2max,error,i4toi2 
     2226        Variable r4 
     2227         
     2228        ib=10 
     2229        nd=4 
     2230        i4max=2767000 
     2231        i2max=32767 
     2232        error=-777 
     2233         
     2234        if(i4 <= i4max) 
     2235                r4=i4 
     2236                if(r4 > i2max) 
     2237                        ipw = ib^nd 
     2238                        npw=0 
     2239                        do 
     2240                                if( !(r4 > (ipw-1)) )           //to simulate a do-while loop evaluating at top 
     2241                                        break 
     2242                                endif 
     2243                                npw=npw+1 
     2244                                r4=r4/ib                 
     2245                        while (1) 
     2246                        i4toi2 = -1*trunc(r4+ipw*npw) 
     2247                else 
     2248                        i4toi2 = trunc(r4)              //shouldn't I just return i4 (as a 2 byte value?) 
     2249                endif 
     2250        else 
     2251                i4toi2=error 
     2252        endif 
     2253        return(i4toi2) 
     2254End 
     2255 
     2256 
     2257// function to fill the extra bits of header information to make a "complete" 
     2258// simulated VAX data file. 
     2259// 
     2260// 
     2261Function SimulationVAXHeader(folder) 
     2262        String folder 
     2263 
     2264        Wave rw=root:Packages:NIST:SAS:realsRead 
     2265        Wave iw=root:Packages:NIST:SAS:integersRead 
     2266        Wave/T tw=root:Packages:NIST:SAS:textRead 
     2267        Wave res=root:Packages:NIST:SAS:results 
     2268         
     2269// integers needed: 
     2270        //[2] count time 
     2271        NVAR ctTime = root:Packages:NIST:SAS:gCntTime 
     2272        iw[2] = ctTime 
     2273         
     2274//reals are partially set in SASCALC initializtion 
     2275        //remaining values are updated automatically as SASCALC is modified 
     2276        // -- but still need: 
     2277        //      [0] monitor count 
     2278        //      [2] detector count (w/o beamstop) 
     2279        //      [4] transmission 
     2280        //      [5] thickness (in cm) 
     2281        NVAR imon = root:Packages:NIST:SAS:gImon 
     2282        rw[0] = imon 
     2283        rw[2] = res[9] 
     2284        rw[4] = res[8] 
     2285        NVAR thick = root:Packages:NIST:SAS:gThick 
     2286        rw[5] = thick 
     2287         
     2288// text values needed: 
     2289// be sure they are padded to the correct length 
     2290        // [0] filename (do I fake a VAX name? probably yes...) 
     2291        // [1] date/time in VAX format 
     2292        // [2] type (use SIM) 
     2293        // [3] def dir (use [NG7SANS99]) 
     2294        // [4] mode? C 
     2295        // [5] reserve (another date), prob not needed 
     2296        // [6] sample label 
     2297        // [9] det type "ORNL  " (6 chars) 
     2298         
     2299        tw[1] = "01-JAN-2009 12:12:12" 
     2300        tw[2] = "SIM" 
     2301        tw[3] = "[NG7SANS99]" 
     2302        tw[4] = "C" 
     2303        tw[5] = "01JAN09 " 
     2304        tw[9] = "ORNL  " 
     2305         
     2306        NVAR index = root:Packages:NIST:SAS:gSaveIndex 
     2307        SVAR prefix = root:Packages:NIST:SAS:gSavePrefix 
     2308 
     2309        tw[0] = prefix+num2str(index)+".SA2_SIM_A"+num2str(index) 
     2310        index += 1 
     2311         
     2312        String labelStr=" "      
     2313        Prompt labelStr, "Enter sample label "          // Set prompt for x param 
     2314        DoPrompt "Enter sample label", labelStr 
     2315        if (V_Flag) 
     2316                //Print "no sample label entered - no file written" 
     2317                index -=1 
     2318                return -1                                                               // User canceled 
     2319        endif 
     2320         
     2321        labelStr = PadString(labelStr,60,0x20)  //60 fortran-style spaces 
     2322        tw[6] = labelStr[0,59] 
     2323         
     2324        return(0) 
     2325End 
  • sans/Dev/trunk/NCNR_User_Procedures/Reduction/SANS/SASCALC.ipf

    r465 r472  
    1717//                                               Lens flux, trans is not corrected for lens/prism transmission 
    1818//                                               Lenses can still be inserted in incorrect cases, and are not automatically taken out 
     19// 27 JAN 2009 SRK - Changed behavior of Lens checkbox. Now, it SETS parameters as needed for proper 
     20//                                               configuration. 17.2 can be typed in for lens/prism on NG3. Invalid conditions 
     21//                                               will automatically uncheck the box 
    1922// 
    2023// calculate what q-values you get based on the instruments settings 
     
    2528// 
    2629// To Do: 
    27 // - add in instrument conditions for lens/(lens+prism) configurations 
    28 // - proper resolution calculation for lens/prism 
    29 // 
    3030// 
    3131// Optional: 
     
    6161                ReCalculateInten(1)             //will use defaults 
    6262        Endif 
    63          
    64         DoWindow/F MC_SASCALC 
    65         if(V_flag==0) 
    66                 MC_SASCALC() 
    67         endif 
     63 
     64// now a checkbox as needed 
     65//      DoWindow/F MC_SASCALC 
     66//      if(V_flag==0) 
     67//              MC_SASCALC() 
     68//      endif 
    6869End 
    6970 
     
    108109         
    109110        // for the MC simulation 
     111        Variable/G root:Packages:NIST:SAS:gRanDateTime=datetime 
    110112        Variable/G root:Packages:NIST:SAS:gImon = 10000 
    111113        Variable/G root:Packages:NIST:SAS:gThick = 0.1 
     
    115117        Variable/G root:Packages:NIST:SAS:gCntTime = 1 
    116118        Variable/G root:Packages:NIST:SAS:gDoMonteCarlo = 0 
     119        Variable/G root:Packages:NIST:SAS:gRawCounts = 0 
     120        Variable/G root:Packages:NIST:SAS:gSaveIndex = 100 
     121        String/G root:Packages:NIST:SAS:gSavePrefix = "SIMUL" 
    117122        Make/O/D/N=10 root:Packages:NIST:SAS:results = 0 
    118         Make/O/T/N=10 root:Packages:NIST:SAS:results_desc = {"total X-section (1/cm)","SAS X-section (1/cm)","number that scatter","number that reach detector","avg # times scattered","fraction single coherent","fraction double coherent","fraction multiple scattered","fraction transmitted","detector counts w/beamstop"} 
     123        Make/O/T/N=10 root:Packages:NIST:SAS:results_desc = {"total X-section (1/cm)","SAS X-section (1/cm)","number that scatter","number that reach detector","avg # times scattered","fraction single coherent","fraction double coherent","fraction multiple scattered","fraction transmitted","detector counts w/o beamstop"} 
    119124         
    120125        //tick labels for SDD slider 
     
    132137        //for plotting 
    133138        Variable/G root:Packages:NIST:SAS:gFreezeCount=1                //start the count at 1 to keep Jeff happy 
     139        Variable/G root:Packages:NIST:SAS:gDoTraceOffset=1              // (1==Yes, offset 2^n), 0==turn off the offset 
     140         
    134141End 
    135142 
     
    283290 
    284291        PauseUpdate; Silent 1           // building window... 
     292 
     293// if I make the graph a subwindow in a panel, it breaks the "append 1d" from the wrapper        
     294//      NewPanel/W=(5,44,463,570)/K=1 as "SASCALC" 
     295//      DoWindow/C SASCALC 
     296//      ModifyPanel cbRGB=(49151,53155,65535) 
     297// 
     298//       
     299//      String fldrSav0= GetDataFolder(1) 
     300//      SetDataFolder root:Packages:NIST:SAS: 
     301//       
     302//      Display/HOST=#/W=(5,200,463,570) aveint vs qval 
     303//      ModifyGraph mode=3 
     304//      ModifyGraph marker=19 
     305//      ModifyGraph rgb=(0,0,0) 
     306//      Modifygraph log=1 
     307//      Modifygraph grid=1 
     308//      Modifygraph mirror=2 
     309//      ModifyGraph msize(aveint)=2 
     310//      ErrorBars/T=0 aveint Y,wave=(sigave,sigave) 
     311//      Label bottom, "Q (1/A)" 
     312//      Label left, "Relative Intensity" 
     313//      legend 
     314//       
     315//      RenameWindow #,G_aveint 
     316//      SetActiveSubwindow ## 
     317 
     318//// end panel commands 
     319 
     320/// draw as a graph 
    285321        String fldrSav0= GetDataFolder(1) 
    286322        SetDataFolder root:Packages:NIST:SAS: 
    287         Display /W=(5,44,463,570)/K=1 aveint vs qval as "SASCALC" 
     323         
     324        Display/W=(5,44,463,570)/K=1  aveint vs qval as "SASCALC" 
    288325        DoWindow/C SASCALC 
    289326        ModifyGraph cbRGB=(49151,53155,65535) 
     
    299336        Label left, "Relative Intensity" 
    300337        legend 
     338         
     339        ControlBar/T 200 
     340 
    301341        SetDataFolder fldrSav0 
    302  
    303  
    304         ControlBar 200 
    305342         
    306343        Slider SC_Slider,pos={11,46},size={150,45},proc=GuideSliderProc,live=0 
     
    344381        CheckBox checkLens,value=root:Packages:NIST:SAS:gUsingLenses 
    345382         
    346 //      CheckBox checkSim,pos={20,165},size={44,14},proc=SimCheckProc,title="Simulation?" 
    347 //      CheckBox checkSim,value=0 
     383        CheckBox checkSim,pos={6,175},size={44,14},proc=SimCheckProc,title="MC Simulation?" 
     384        CheckBox checkSim,value=0 
    348385         
    349386        // set up a fake dependency to trigger recalculation 
     
    431468        Variable event  // bit field: bit 0: value set, 1: mouse down, 2: mouse up, 3: mouse moved 
    432469         
     470        Variable recalc=0 
     471         
    433472        if(event %& 0x1)        // bit 0, value set 
    434                 if(sliderValue != 0) 
    435                         LensCheckProc("",0)             //make sure lenses are deselected 
     473                if(cmpstr(ctrlName,"") != 0)            //here by direct action, so do LensCheck and recalculate 
     474                        recalc=1 
     475                        LensCheckProc("",2)             //make sure lenses are deselected 
    436476                endif 
    437477                sourceToSampleDist()            //updates the SSD global and wave 
    438478                //change the sourceAp popup, SDD range, etc 
    439479                UpdateControls() 
    440                 ReCalculateInten(1) 
     480                ReCalculateInten(recalc) 
    441481        endif 
    442482        return 0 
     
    450490        Variable event  // bit field: bit 0: value set, 1: mouse down, 2: mouse up, 3: mouse moved 
    451491 
     492        Variable recalc=0 
    452493        if(event %& 0x1)        // bit 0, value set 
    453                 if(sliderValue < 1300) 
    454                         LensCheckProc("",0)             //make sure lenses are deselected 
     494                if(cmpstr(ctrlName,"") != 0) 
     495                        recalc=1 
     496                        LensCheckProc("",2)             //make sure lenses are only selected for valid configurations 
    455497                endif 
    456498                sampleToDetectorDist()          //changes the SDD and wave (DetDist is the global) 
    457                 ReCalculateInten(1) 
     499                ReCalculateInten(recalc) 
    458500        endif 
    459501 
     
    493535                initNG7() 
    494536        endif 
     537        LensCheckProc("",2)             //check if lenses are still valid (they won't be) 
    495538        UpdateControls() 
    496539        ReCalculateInten(1) 
     
    520563 
    521564//lenses (or prisms) in/out changes resolution 
     565// 
     566// passing in a checked == 2 will do a check of the configuration without 
     567// affecting the box state 
     568// 
     569// if an invalid configuration is detected, the box is unchecked 
     570// and the lens flag is set to zero (=out). 
     571// 
     572// When necessary controls are "popped", a ctrlName="" is passed to signal the control 
     573// to NOT recalculate the intensity, and to NOT (recursively) call LensCheckProc again 
     574// 
     575// currently, the 17.2 A for lens/prism @ ng3 must be typed in 
     576// 
    522577Function LensCheckProc(ctrlName,checked) : CheckBoxControl 
    523578        String ctrlName 
     
    531586        NVAR lam = root:Packages:NIST:SAS:gLambda 
    532587        NVAR dist = root:Packages:NIST:SAS:gDetDist 
    533          
    534         if( (Ng != 0) || (lam < 8) || (dist < 1300) ) 
     588        NVAR instrument = root:Packages:NIST:SAS:instrument 
     589        Wave rw=root:Packages:NIST:SAS:realsRead 
     590         
     591        // directly uncheck the box, just set the flag and get out 
     592        if(checked == 0) 
    535593                lens = 0 
    536594                CheckBox checkLens,value=0 
     595                rw[28]=0                //flag for lenses out 
     596                ReCalculateInten(1) 
    537597                return(0) 
    538598        endif 
    539         lens = checked 
    540          
    541         ReCalculateInten(1) 
    542 End 
    543  
    544 ////simulation control panel 
    545 //Function SimCheckProc(ctrlName,checked) : CheckBoxControl 
    546 //      String ctrlName 
    547 //      Variable checked 
    548 // 
    549 //      if(checked) 
    550 //              DoWindow/F MC_SASCALC 
    551 //              if(V_flag==0) 
    552 //                      Execute "MC_SASCALC()" 
    553 //              endif 
    554 //      endif 
    555 //      return(0) 
    556 //End 
     599         
     600        // check the box, enforce the proper conditions 
     601        if(checked == 1) 
     602                lens = checked 
     603                if(instrument == 3) 
     604                        dist = 1317 
     605                        DetDistSliderProc("",1317,1) 
     606                         
     607                        lam = 8.4 
     608                        LambdaSetVarProc("",8.4,"8.4","")  
     609 
     610                        ng=0 
     611                        GuideSliderProc("",0,1)         //this updates the controls to the new # of guides 
     612                         
     613                        PopupMenu popup0,mode=1,popvalue="1.43 cm"              //first item in source aperture menu 
     614                         
     615                        PopupMenu popup0_2,mode=2               //deltaLambda 
     616                        ControlInfo popup0_2 
     617                        DeltaLambdaPopMenuProc("",0,S_value)                    //zero as 2nd param skips recalculation 
     618                else 
     619                        dist = 1531 
     620                        DetDistSliderProc("",1531,1) 
     621                         
     622                        lam = 8.09 
     623                        LambdaSetVarProc("",8.09,"8.09","")  
     624                         
     625                        ng=0 
     626                        GuideSliderProc("",0,1) 
     627                        PopupMenu popup0,mode=1,popvalue="1.43 cm"              //first item 
     628                         
     629                        PopupMenu popup0_2,mode=2               //deltaLambda 
     630                        ControlInfo popup0_2 
     631                        DeltaLambdaPopMenuProc("",0,S_value)                    //zero as 2nd param skips recalculation 
     632                endif 
     633                rw[28]=1                //flag for lenses in (not the true number, but OK) 
     634                ReCalculateInten(1) 
     635        endif 
     636         
     637        // this is my internal check to see if conditions are still valid 
     638        // I'll uncheck as needed 
     639        if(checked == 2) 
     640 
     641                // source aperture must be 1.43 cm diameter 
     642                // number of guides must be zero 
     643                Variable a1 = sourceApertureDiam() 
     644                if(a1 != 1.43  || Ng !=0) 
     645                        lens = 0 
     646                        CheckBox checkLens,value=0 
     647                        rw[28]=0                //flag for lenses out 
     648                        return(0) 
     649                endif 
     650         
     651                // instrument specific distance requirements 
     652                if(instrument == 3 && dist != 1317) 
     653                        lens = 0 
     654                        CheckBox checkLens,value=0 
     655                        rw[28]=0                //flag for lenses out 
     656                        return(0) 
     657                endif 
     658         
     659                if(instrument == 7 && dist != 1531) 
     660                        lens = 0 
     661                        CheckBox checkLens,value=0 
     662                        rw[28]=0                //flag for lenses out 
     663                        return(0) 
     664                endif 
     665                 
     666                // instrument specific wavelength requirements 
     667                if(instrument == 3 && !(lam == 8.4 || lam == 17.2) ) 
     668                        lens = 0 
     669                        CheckBox checkLens,value=0 
     670                        rw[28]=0                //flag for lenses out 
     671                        return(0) 
     672                endif 
     673                 
     674                if(instrument == 7 && lam != 8.09 ) 
     675                        lens = 0 
     676                        CheckBox checkLens,value=0 
     677                        rw[28]=0                //flag for lenses out 
     678                        return(0) 
     679                endif 
     680                 
     681        endif 
     682 
     683        return(1)               //return value not used 
     684End 
     685 
     686//simulation ccontrols as a control bar that toggles on/off to the right 
     687Function SimCheckProc(ctrlName,checked) : CheckBoxControl 
     688        String ctrlName 
     689        Variable checked 
     690 
     691        if(checked) 
     692                //MoveWindow/W=SASCALC 5,44,763,570             //to resize 
     693                // draw the controls 
     694                DoWindow/F MC_SASCALC 
     695                if(V_flag==0) 
     696                        Execute "MC_SASCALC()" 
     697                        AutoPositionWindow/M=1/R=SASCALC MC_SASCALC 
     698                endif 
     699        else 
     700                //get rid of the controls 
     701                DoWindow MC_SASCALC 
     702                if(V_flag!=0) 
     703                        KillWindow MC_SASCALC 
     704                endif 
     705                //MoveWindow/W=SASCALC 5,44,463,570             //to resize 
     706                //KillWindow SASCALC#T_results 
     707        endif 
     708 
     709        return(0) 
     710End 
    557711 
    558712// change the source aperture 
     
    565719        Variable a1 = sourceApertureDiam()              //sets the new value in the wave 
    566720         
     721        // if LensCheckProc is calling this, don't call it again. 
     722        // if this is called by a direct pop, then check 
     723        if(cmpstr(ctrlName,"") != 0) 
     724                LensCheckProc("",2)             //make sure lenses are only selected for valid configurations 
     725        endif 
     726         
    567727        ReCalculateInten(popnum)                //skip the recalculation if I pass in a zero 
    568728End 
     
    588748         
    589749        sampleToDetectorDist() 
    590          
     750        if(cmpstr(ctrlName,"") != 0) 
     751                LensCheckProc("",2)             //make sure lenses are only selected for valid configurations 
     752        endif 
    591753        ReCalculateInten(1) 
    592754End 
     
    615777 
    616778        WAVE rw=root:Packages:NIST:SAS:realsRead 
     779        Variable recalc=0 
     780         
    617781        rw[26] = str2num(varStr) 
    618         ReCalculateInten(1) 
     782        if(cmpstr(ctrlName,"") != 0) 
     783                recalc=1 
     784                LensCheckProc("",2)             //make sure lenses are only selected for valid configurations 
     785        endif 
     786        ReCalculateInten(recalc) 
    619787        return(0) 
    620788End 
     
    663831                return(0) 
    664832        endif 
     833//      Print "recalculate" 
    665834         
    666835        // update the wave with the beamstop diameter here, since I don't know what 
     
    784953 
    785954                t0 = (stopMSTimer(-2) - t0)*1e-6 
    786                 Printf  "MC sim time = %g seconds\r\r",t0 
     955                Printf  "MC sim time = %g seconds\r",t0 
    787956                 
    788957                trans = results[8]                      //(n1-n2)/n1 
     
    794963                 
    795964                linear_data[xCtr][yCtr] = 0                     //snip out the transmitted spike 
    796                 Print "counts on detector not transmitted = ",sum(linear_data,-inf,inf) 
     965//              Print "counts on detector not transmitted = ",sum(linear_data,-inf,inf) 
    797966 
    798967                // or simulate a beamstop 
     
    805974                 
    806975                linear_data *= tmp_mask 
    807                 Print "counts on detector not behind beamstop = ",sum(linear_data,-inf,inf) 
    808976                results[9] = sum(linear_data,-inf,inf) 
     977                //              Print "counts on detector not behind beamstop = ",results[9] 
    809978                 
    810979                // convert to absolute scale 
     
    812981//              kappa = beamInten*pi*r1*r1*thick*(pixSize/sdd)^2*trans*(iMon/beaminten) 
    813982                kappa = thick*(pixSize/sdd)^2*trans*iMon 
    814  
    815                 linear_data = linear_data / kappa 
    816                  
     983                 
     984                //use kappa to get back to counts => linear_data = round(linear_data*kappa) 
     985                Note/K linear_data ,"KAPPA="+num2str(kappa)+";" 
     986                 
     987                NVAR rawCts = root:Packages:NIST:SAS:gRawCounts 
     988                if(!rawCts)                     //go ahead and do the linear scaling 
     989                        linear_data = linear_data / kappa 
     990                endif            
    817991                data = linear_data 
    818992                 
    819993                // re-average the 2D data 
    820994                S_CircularAverageTo1D("SAS") 
    821                 // multiply either estimate by beamstop shadowing 
    822                  
    823 //              aveint *= fSubS 
    824  
     995                 
    825996                // put the new result into the simulation folder 
    826997                Fake1DDataFolder(qval,aveint,sigave,sigmaQ,qbar,fSubs,"Simulation")      
     
    8731044        Duplicate/O sigave,$("sigave_"+num2str(ct)) 
    8741045        Appendtograph $("aveint_"+num2str(ct)) vs $("qval_"+num2str(ct)) 
    875         ModifyGraph mode=3 
    876         ModifyGraph marker=19 
     1046        ModifyGraph mode($("aveint_"+num2str(ct)))=3 
     1047        ModifyGraph marker($("aveint_"+num2str(ct)))=19 
    8771048        ModifyGraph msize($("aveint_"+num2str(ct)))=2 
    8781049        ErrorBars/T=0 $("aveint_"+num2str(ct)) Y,wave=($("sigave_"+num2str(ct)),$("sigave_"+num2str(ct))) 
     
    9111082        endswitch 
    9121083         
     1084        NVAR doTraceOffset = root:Packages:NIST:SAS:gDoTraceOffset 
    9131085        NVAR offset = root:Packages:NIST:SAS:gModelOffsetFactor 
    914         offset = 2^ct 
    915         //multiply by current offset (>=1) 
    916         Wave inten = $("aveint_"+num2str(ct)) 
    917         inten *= offset 
    918 //      Print "new offset = ",offset 
     1086        if(doTraceOffset) 
     1087                offset = 2^ct 
     1088                //multiply by current offset (>=1) 
     1089                Wave inten = $("aveint_"+num2str(ct)) 
     1090                inten *= offset 
     1091                //      Print "new offset = ",offset 
     1092        endif 
    9191093         
    9201094        ct +=1 
  • sans/Dev/trunk/NCNR_User_Procedures/Reduction/SANS/WriteQIS.ipf

    r467 r472  
    830830// returns the path to the file, or null if the user cancelled 
    831831// fancy use of optional parameters 
     832//  
     833// enforce short file names (26 characters) 
    832834Function/S DoSaveFileDialog(msg,[fname,suffix]) 
    833835        String msg,fname,suffix 
     
    844846        endif 
    845847         
    846         String outputPath,tmpName 
     848        String outputPath,tmpName,testStr 
     849        Variable badLength=0,maxLength=26,l1,l2 
     850         
     851         
    847852        tmpName = fname + suffix 
    848853         
    849         Open/D/M=msg/T="????" refNum as tmpName 
    850         outputPath = S_fileName 
     854        do 
     855                badLength=0 
     856                Open/D/M=msg/T="????" refNum as tmpName 
     857                outputPath = S_fileName 
     858                 
     859                testStr = ParseFilePath(0, outputPath, ":", 1, 0)               //just the filename 
     860                if(strlen(testStr)==0) 
     861                        break           //cancel, allow exit 
     862                endif 
     863                if(strlen(testStr) > maxLength) 
     864                        badlength = 1 
     865                        DoAlert 2,"File name is too long. Is\r"+testStr[0,25]+"\rOK?" 
     866                        if(V_flag==3) 
     867                                outputPath = "" 
     868                                break 
     869                        endif 
     870                        if(V_flag==1)                   //my suggested name is OK, so trim the output 
     871                                badlength=0 
     872                                l1 = strlen(testStr)            //too long length 
     873                                l1 = l1-maxLength               //number to trim 
     874                                //Print outputPath 
     875                                l2=strlen(outputPath) 
     876                                outputPath = outputPath[0,l2-1-l1] 
     877                                //Print "modified  ",outputPath 
     878                        endif 
     879                        //if(V_flag==2)  do nothing, let it go around again 
     880                endif 
     881                 
     882        while(badLength) 
    851883         
    852884        return outputPath 
  • sans/Dev/trunk/NCNR_User_Procedures/Reduction/USANS/COR_Graph.ipf

    r433 r472  
    309309                Cursor/K A 
    310310                Cursor/K B 
     311                CheckBox useCrsrCheck,value= 0 
    311312        endif 
    312313        DoUpdate 
  • sans/Dev/trunk/NCNR_User_Procedures/Reduction/USANS/Main_USANS.ipf

    r433 r472  
    904904                        break 
    905905        endswitch 
     906        // uncheck the cursors 
     907        UseCrsrCheckProc("",0) 
     908         
    906909        DoWindow/F USANS_Panel          //focus back to MainPanel 
    907910        SetDataFolder root: 
     
    12901293End 
    12911294 
    1292  
  • sans/Dev/trunk/NCNR_User_Procedures/Reduction/USANS/USANS_Includes.ipf

    r432 r472  
    2020#include "CheckVersionFTP"                              //added June 2008 
    2121#include "GaussUtils_v40"                               //added Oct 2008 for unified file loading 
     22#include "WriteQIS"                             //added Jan 2009 for fileSaveDialog 
  • sans/Dev/trunk/NCNR_User_Procedures/Reduction/USANS/WriteUSANSData.ipf

    r404 r472  
    5151        dumWave = - DQv 
    5252        /// 
    53          
    5453        if(dialog) 
    55                 PathInfo/S savePathName 
    56                 Open/D/T="????" refnum as fullpath              //won't actually open the file 
    57                 If(cmpstr(S_filename,"")==0) 
     54                PathInfo/S catPathName 
     55                fullPath = DoSaveFileDialog("Save data as") 
     56                If(cmpstr(fullPath,"")==0) 
    5857                        //user cancel, don't write out a file 
    5958                        Close/A 
    6059                        Abort "no data file was written" 
    6160                Endif 
    62                 fullpath = S_filename 
     61                //Print "dialog fullpath = ",fullpath 
    6362        Endif 
    6463         
Note: See TracChangeset for help on using the changeset viewer.