source: sans/Dev/trunk/NCNR_User_Procedures/Reduction/Polarization/Pol_PolarizationPanels.ipf @ 824

Last change on this file since 824 was 824, checked in by srkline, 12 years ago

Changed 2-yukawa to have better names for the parameters, a macro to plot g(r), and to return S(q)=1000 if the calculation fails, to be more obvious.

Added a Corrlation matrix function (in Wrapper.ipf), but it's not linked anywhere yet, since I don't know yet how best to display it.

Simplified the function to list .ASC files

Added comments to the polarization panel procedures.

File size: 38.0 KB
Line 
1#pragma rtGlobals=1             // Use modern global access method.
2
3
4// Polarized Beam Reduction Procedures
5//
6//
7// input panels to set and calculate polarization parameters necessary for the
8// matrix corrections to the cross sections
9//
10// -1- Fundamental Cell Parameters -- these are constants, generally not editable. (this file)
11// -2- Decay Parameters -- these are fitted values based on transmission mearurements (this file)
12// -3- Flipper Panel is in its own procedure (FlipperPanel.ipf)
13// -4- PolCor_Panel is in PolarizationCorrection.ipf
14
15//
16// Driven by 4 panels to get the necessary information from the users
17// -1- Fundamental cell parameters: root:Packages:NIST:Polarization:Cells
18//              - default cell parameters are loaded. More cell definitions can be added as more cells are used
19//              - changes are saved per experiment
20//              - important parameters are held in global key=value strings gCell_<name>
21//              - cell names and parameters are used by the 2nd panel for calculation of the Decay constant
22//
23// -2- Decay Constant Panel
24//              - decay constant determined for each cell.
25//              - popping the cell name makes 2 waves, Decay_<cellname> and DecayCalc_<cellname>
26//              - Decay_ is the wave presented in the table. Specified transmission run numbers are entered
27//                      and "Calc Sel Row" does the calculation of mu and Pcell (for all rows, actually)
28//              - DimLabels are used for the arrays to make the column identity more readable than simply an index
29//              - time=0 is taken from the first file
30//              - Calculations are based on the count rate of the file, corrected for monitor and attenuation
31//              - alerts are posted for files in any row that are not at the same attenuation or SDD
32//              - if "include" column is == 1, that row will be included in the fit of the decay data
33//              - excluded points are plotted in red
34//              - results of the fit are printed on the panel, and written to the wave note of the Decay_ wave
35//                      (not DecayCalc_) for use in the next panel
36//              - manual entry of all of the parameters in the wave note is allowed.
37//
38//
39// -3- Flipper Panel (not in this procedure - in Pol_FlipperPanel.ipf)
40//              - calculates the flipper and supermirror efficiencies for a given cell AND "condition"
41//              - start by entering a condition name and choosing a cell
42//              - Waves Cond_<condition>_<cell> and CondCalc_<condition>_<cell> are created
43//              - DimLabels are used for the arrays to make the column identity more readable than simply an index
44//              - enter transmission run numbers as specified in the table
45//              - Do Average will calculate the Psm and PsmPfl values (and errors) and average if more than
46//                      one row of data is present (and included)
47//              - results are printed on the panel, and written to the wave note of Cond_<condition>_<cell>
48//              - results are used in the calculation of the polarization matrix
49//
50//
51// -4- PolCor_Panel (not in this procedure - in Pol_PolarizationCorrection.ipf)
52//              - gets all of the parameters from the user to do the polariztion correction, then the "normal" SANS reduction
53//              - 5 files can be added together for each of the different spin states (more than this??)
54//              - global strings in root:Packages:NIST:Polarization:gStr_PolCor_<tab>_<flip>_<position> hold the run number
55//              - polarization condition is set with the popup
56//              - the same fields/pops are duplicated (hidden) for the SAM/EMP/BGD tabs as needed
57//              - on loading of the data, the 2-letter spin state is tagged onto the loaded waves (all of them)
58//              - displayed data is simply re-pointed to the desired data
59//              - on loading, the raw files are added together as ususal, normalized to monitor counts. Then each contribution
60//                      of the file to the polarization matrix is added (scaling each by mon/1e8)
61//              - loaded data and PolMatrix are stored in the ususal SAM, EMP, BGD folders.
62//              - Polarization correction is done with one click (one per tab). "_pc" tags are added to the resulting names,
63//                      and copies of all of the associated waves are again copied (wasteful), but makes switching display very easy
64//              - Once all of the polariztion correction is done, then the UU_pc (etc.) data can be reduced as usual (4 passes)
65//              - protocol is built as ususal, from this panel only (since the SAM, EMP, and BGD need to be switched, rather than loaded
66//              - protocols can be saved/recalled.
67//              - reduction will always ask for a protocol rather than using what's on the panel.
68//              - closing the panel will save the state (except the protocol). NOT initializing when re-opening will restore the
69//                      state of the entered runs and the popups of conditions.
70//
71//
72//
73//
74
75
76
77
78//
79// Panel -1-
80//
81// Fundamental He cell parameters. Most of these are pre-defined, so that they are supplied as a
82// static table, only edited as parameters are refined.
83//
84// work with this as kwString
85// cell=nameStr
86// lambda=num
87// Te=num
88// err_Te=num
89// mu=nnum
90// err_mu=num
91//
92//
93// for this panel, the cell parameters are stored as kw strings
94// all of the strings start w/ "gCell_"
95//
96Macro ShowCellParamPanel()
97       
98        // init folders
99        // ASK before initializing cell constants
100        // open the panel
101        DoWindow/F CellParamPanel
102        if(V_flag == 0)
103                InitPolarizationFolders()
104                DoAlert 1,"Do you want to use default parameters?"
105                if(V_flag == 1)
106                        InitPolarizationGlobals()
107                endif
108                Make_HeCell_ParamWaves()
109                CellParamPanel()
110        endif
111
112end
113
114// setup the data folder, etc
115//
116//
117Function InitPolarizationFolders()
118
119        NewDataFolder/O root:Packages:NIST:Polarization
120        NewDataFolder/O root:Packages:NIST:Polarization:Cells                   //holds the cell constants and waves
121       
122        SetDataFolder root:
123        return(0)
124End
125
126//
127// add more cells here as they are defined
128//
129Function InitPolarizationGlobals()
130
131        SetDataFolder root:Packages:NIST:Polarization:Cells
132       
133        // cell constants
134        String/G gCell_Maverick = "cell=Maverick,lambda=5.0,Te=0.87,err_Te=0.01,mu=3.184,err_mu=0.2,"
135        String/G gCell_Burgundy = "cell=Burgundy,lambda=5.0,Te=0.86,err_Te=0.01,mu=3.138,err_mu=0.15,"
136        String/G gCell_Olaf = "cell=Olaf,lambda=7.5,Te=0.86,err_Te=0.005,mu=2.97,err_mu=0.18,"
137       
138       
139        SetDataFolder root:
140        return(0)
141End
142
143
144// parse strings to fill in waves
145//
146//
147Function Make_HeCell_ParamWaves()
148
149        SetDataFolder root:Packages:NIST:Polarization:Cells
150       
151        String listStr,item
152        Variable num,ii
153       
154        // get a list of the strings
155        listStr=StringList("gCell_*",";")
156        num=ItemsInList(listStr,";")
157        print listStr
158       
159        Make/O/T/N=0 CellName
160        Make/O/N=0 lambda,Te,err_Te,mu,err_mu
161       
162        // parse the strings to fill the table
163        for(ii=0;ii<num;ii+=1)
164                item = StringFromList(ii, listStr,";")
165                SVAR gStr = $item
166                InsertPoints  ii, 1, CellName,lambda,Te,err_Te,mu,err_mu
167                CellName[ii] = StringByKey("cell", gStr, "=", ",", 0)
168                lambda[ii] = NumberByKey("lambda", gStr, "=", ",", 0)
169                Te[ii] = NumberByKey("Te", gStr, "=", ",", 0)
170                err_Te[ii] = NumberByKey("err_Te", gStr, "=", ",", 0)
171                mu[ii] = NumberByKey("mu", gStr, "=", ",", 0)
172                err_mu[ii] = NumberByKey("err_mu", gStr, "=", ",", 0)
173               
174        endfor
175
176       
177        SetDataFolder root:
178        return(0)
179End
180
181// take the waves from the table and write these back to the string, only for the current experiment
182//
183Function Save_HeCell_ParamWaves()
184
185        SetDataFolder root:Packages:NIST:Polarization:Cells
186       
187        String listStr,item,dummyStr
188        Variable num,ii
189       
190        // get a list of the strings
191        listStr=StringList("gCell_*",";")
192        num=ItemsInList(listStr,";")
193        KillStrings/Z listStr
194       
195        Wave/T CellName
196        Wave lambda,Te,err_Te,mu,err_mu
197       
198        dummyStr = "cell=Maverick,lambda=5.0,Te=0.87,err_Te=0.01,mu=3.184,err_mu=0.2,"
199       
200        num=numpnts(CellName)
201       
202        // parse the table to fill the Strings
203        for(ii=0;ii<num;ii+=1)
204                item = "gCell_"+CellName[ii]
205                String/G $item = dummyStr
206                SVAR kwListStr = $item
207               
208                kwListStr = ReplaceStringByKey("cell", kwListStr, CellName[ii], "=", ",", 0)
209                kwListStr = ReplaceNumberByKey("lambda", kwListStr, lambda[ii], "=", ",", 0)
210                kwListStr = ReplaceNumberByKey("Te", kwListStr, Te[ii], "=", ",", 0)
211                kwListStr = ReplaceNumberByKey("err_Te", kwListStr, err_Te[ii], "=", ",", 0)
212                kwListStr = ReplaceNumberByKey("mu", kwListStr, mu[ii], "=", ",", 0)
213                kwListStr = ReplaceNumberByKey("err_mu", kwListStr, err_mu[ii], "=", ",", 0)
214               
215        endfor
216
217        SetDataFolder root:
218        return(0)
219End
220
221
222// makes the panel after the waves are generated
223//
224// allow edits of the cells to update the string values
225// add a button to "revert" (with warning)
226// add a button to add new cells (insert a new row in the table, then update)
227//
228Function CellParamPanel()
229
230        SetDataFolder root:Packages:NIST:Polarization:Cells
231       
232        PauseUpdate; Silent 1           // building window...
233        NewPanel /W=(775,44,1375,377) /N=CellParamPanel/K=1 as "Fundamental Cell Parameters"
234        ModifyPanel cbRGB=(65535,49151,55704)
235        ModifyPanel fixedSize=1
236
237//      ShowTools/A
238        Button button_0,pos={10,10},size={90,20},proc=AddCellButtonProc,title="Add Cell"
239        Button button_1,pos={118,10},size={130,20},proc=SaveCellParButtonProc,title="Save Parameters"
240        Button button_2,pos={265,10},size={130,20},proc=RevertCellParButtonProc,title="Revert Parameters"
241        Button button_3,pos={420,10},size={35,20},proc=CellHelpParButtonProc,title="?"
242
243       
244        Edit/W=(14,55,582,318)/HOST=#
245        ModifyTable width(Point)=0
246        RenameWindow #,T0
247
248        WAVE/T CellName
249        WAVE lambda,Te,err_Te,mu,err_mu
250
251        AppendtoTable/W=# CellName,lambda,Te,err_Te,mu,err_mu
252        SetActiveSubwindow ##
253
254        SetDataFolder root:
255        return(0)
256End
257
258Function CellHelpParButtonProc(ba) : ButtonControl
259        STRUCT WMButtonAction &ba
260
261        switch( ba.eventCode )
262                case 2: // mouse up
263                        // click code here
264                        DoAlert 0,"Help for Cell Param Panel not written yet"
265                        break
266                case -1: // control being killed
267                        break
268        endswitch
269
270        return 0
271End
272
273
274Function AddCellButtonProc(ba) : ButtonControl
275        STRUCT WMButtonAction &ba
276
277        switch( ba.eventCode )
278                case 2: // mouse up
279                        // click code here
280                        SetDataFolder root:Packages:NIST:Polarization:Cells
281
282                        WAVE/T CellName
283                        WAVE lambda,Te,err_Te,mu,err_mu
284                        Variable ii= numpnts(CellName)
285                       
286                        InsertPoints  ii, 1, CellName,lambda,Te,err_Te,mu,err_mu
287                       
288                        SetDataFolder root:
289                        break
290                case -1: // control being killed
291                        break
292        endswitch
293
294        return 0
295End
296
297Function SaveCellParButtonProc(ba) : ButtonControl
298        STRUCT WMButtonAction &ba
299
300        switch( ba.eventCode )
301                case 2: // mouse up
302                        // click code here
303                        Save_HeCell_ParamWaves()
304                        break
305                case -1: // control being killed
306                        break
307        endswitch
308
309        return 0
310End
311
312Function RevertCellParButtonProc(ba) : ButtonControl
313        STRUCT WMButtonAction &ba
314
315        switch( ba.eventCode )
316                case 2: // mouse up
317                        // click code here
318                        InitPolarizationGlobals()
319                        Make_HeCell_ParamWaves()
320                        break
321                case -1: // control being killed
322                        break
323        endswitch
324
325        return 0
326End
327
328// END PROCEDURES for He cell parameters
329/////////////////////////////////
330
331
332
333
334
335
336// Decay parameters for each cell. Results are stored in a wave note for each cell
337//
338//      muP=
339//      err_muP=
340// P0=
341//      err_P0=         ? is this needed?
342//      T0=
343// gamma=
344//      err_gamma=
345//
346// str = "muP=2,err_muP=0,P0=0.6,err_P0=0,T0=asdf,gamma=200,err_gamma=0,"
347//
348//
349// for this panel, the cell parameters are stored as kw strings
350// all of the strings start w/ "gDecay_"
351//
352Macro ShowCellDecayPanel()
353       
354        // init folders
355        // ASK before initializing cell constants
356        // open the panel
357        DoWindow/F DecayPanel
358        if(V_flag == 0)
359                InitPolarizationFolders()
360                InitDecayGlobals()
361                DecayParamPanel()
362        endif
363end
364
365Function InitDecayGlobals()
366
367        SetDataFolder root:Packages:NIST:Polarization:Cells
368       
369        String/G gMuPo = "muPo"
370        String/G gPo = "Po"
371        String/G gGamma = "gamma"
372        String/G gT0 = "today's the day"
373       
374       
375        SetDataFolder root:
376        return(0)
377End
378
379
380
381
382// makes the panel for the decay parameter and gamma fitting
383//
384Function DecayParamPanel()
385
386        SetDataFolder root:Packages:NIST:Polarization:Cells
387       
388        PauseUpdate; Silent 1           // building window...
389        NewPanel /W=(759,44,1572,713)/N=DecayPanel/K=1 as "Cell Decay Parameters"
390        ModifyPanel cbRGB=(32768,54615,65535)
391//      Button button_3,pos={505,16},size={35,20},proc=DecayHelpParButtonProc,title="?"
392        PopupMenu popup_0,pos={32,18},size={49,20},title="Cell",proc=DecayPanelPopMenuProc
393        PopupMenu popup_0,mode=1,value= #"D_CellNameList()"
394       
395        Button button_0,pos={584,365},size={70,20},proc=DecayFitButtonProc,title="Do Fit"
396       
397        GroupBox group_0,pos={550,399},size={230,149},title="FIT RESULTS",fSize=10
398        GroupBox group_0,fStyle=1
399        SetVariable setvar_0,pos={560,428},size={200,13},title="muPo of 3He"
400        SetVariable setvar_0,fStyle=1,limits={0,0,0},barmisc={0,1000}
401        SetVariable setvar_0,value= root:Packages:NIST:Polarization:Cells:gMuPo
402        SetVariable setvar_1,pos={560,460},size={200,13},title="Po of 3He"
403        SetVariable setvar_1,fStyle=1,limits={0,0,0},barmisc={0,1000}
404        SetVariable setvar_1,value= root:Packages:NIST:Polarization:Cells:gPo
405        SetVariable setvar_2,pos={560,518},size={200,13},title="Gamma (h)",fStyle=1
406        SetVariable setvar_2,limits={0,0,0},barmisc={0,1000}
407        SetVariable setvar_2,value= root:Packages:NIST:Polarization:Cells:gGamma
408        SetVariable setvar_3,pos={560,488},size={200,15},title="T0",fStyle=1
409        SetVariable setvar_3,limits={0,0,0},value= root:Packages:NIST:Polarization:Cells:gT0
410       
411
412        Button button_1,pos={579,294},size={120,20},proc=CalcRowParamButton,title="Calc Sel Row"
413        Button button_2,pos={307,18},size={110,20},proc=ClearDecayWavesButton,title="Clear Table"
414        Button button_3,pos={579,333},size={120,20},proc=ShowCalcRowButton,title="Show Calc"
415        Button button_4,pos={440,18},size={110,20},proc=ClearDecayWavesRowButton,title="Clear Row"
416        Button button_5,pos={620,18},size={40,20},proc=DecayHelpParButtonProc,title="?"
417        Button button_6,pos={620,620},size={100,20},proc=WindowSnapshotButton,title="Snapshot"
418        Button button_7,pos={620,580},size={130,20},proc=ManualEnterDecayButton,title="Manual Entry"
419
420
421
422        // table
423        Edit/W=(14,55,794,275)/HOST=#
424        ModifyTable format=1,width=0
425        RenameWindow #,T0
426        SetActiveSubwindow ##
427       
428        // graph
429        Display/W=(15,291,540,652)/HOST=#  //root:yy vs root:xx
430        ModifyGraph frameStyle=2
431        ModifyGraph mode=4
432        ModifyGraph marker=19
433        ModifyGraph rgb=(0,0,0)
434        ModifyGraph msize=2
435
436        Legend
437//      ModifyGraph log(left)=1
438//      ErrorBars yy OFF
439        RenameWindow #,G0
440        SetActiveSubwindow ##
441
442        SetDataFolder root:
443        return(0)
444End
445
446// allows manual entry of Decay values
447//
448// see DecayFitButtonProc
449//
450Function ManualEnterDecayButton(ba) : ButtonControl
451        STRUCT WMButtonAction &ba
452
453        Variable selRow,err=0
454        String fname, t0str, condStr,noteStr,t1Str,cellStr
455
456        switch( ba.eventCode )
457                case 2: // mouse up
458                        // click code here
459                        Variable gamma_val,err_gamma,muPo, err_muPo, Po, err_Po, runNum
460
461                        ControlInfo/W=DecayPanel popup_0
462                        cellStr = S_Value
463                               
464//                      SetDataFolder root:Packages:NIST:Polarization:Cells:
465                       
466                        WAVE decay=$("root:Packages:NIST:Polarization:Cells:Decay_"+cellStr)            //the one that is displayed
467//                      WAVE calc=$("root:Packages:NIST:Polarization:Cells:DecayCalc_"+cellStr)         //with the results
468
469
470                        Prompt Po, "Enter Po: "         
471                        Prompt err_Po, "Enter err_Po: "         
472                        Prompt muPo, "Enter muPo: "             
473                        Prompt err_muPo, "Enter err_muPo: "             
474                        Prompt gamma_val, "Enter gamma: "               
475                        Prompt err_gamma, "Enter err_gamma: "
476                        Prompt runNum,"Run number for time=0 of decay" 
477                        DoPrompt "Enter Cell Decay Parameters", Po, err_Po, muPo, err_muPo, gamma_val, err_gamma, runNum
478                        if (V_Flag)
479                                return -1                                                               // User canceled
480                        endif
481                       
482                        fname = FindFileFromRunNumber(runNum)
483                        t0str = getFileCreationDate(fname)
484                                       
485//              for the wave note
486                        noteStr = note(decay)
487                        noteStr = ReplaceNumberByKey("muP", noteStr, MuPo ,"=", ",", 0)
488                        noteStr = ReplaceNumberByKey("P0", noteStr, Po ,"=", ",", 0)
489                        noteStr = ReplaceNumberByKey("err_muP", noteStr, err_muPo ,"=", ",", 0)
490                        noteStr = ReplaceNumberByKey("err_P0", noteStr, err_Po ,"=", ",", 0)
491                        noteStr = ReplaceNumberByKey("gamma", noteStr, gamma_val ,"=", ",", 0)
492                        noteStr = ReplaceNumberByKey("err_gamma", noteStr, err_gamma ,"=", ",", 0)
493                        noteStr = ReplaceStringByKey("T0", noteStr, t0Str  ,"=", ",", 0)
494                        // replace the string
495                        Note/K decay
496                        Note decay, noteStr
497
498                        // for the panel display
499                        SVAR gGamma  = root:Packages:NIST:Polarization:Cells:gGamma
500                        SVAR gMuPo = root:Packages:NIST:Polarization:Cells:gMuPo
501                        SVAR gPo  = root:Packages:NIST:Polarization:Cells:gPo           
502                        SVAR gT0 = root:Packages:NIST:Polarization:Cells:gT0
503                       
504                        gT0 = t0Str             //for display
505                        sprintf gMuPo, "%g +/- %g",muPo, err_muPo
506                        sprintf gPo, "%g +/- %g",Po,err_Po
507                        sprintf gGamma, "%g +/- %g",gamma_val,err_gamma
508
509                       
510                        break
511                case -1: // control being killed
512                        break
513        endswitch
514
515        return 0
516End
517
518
519Function DecayPanelPopMenuProc(pa) : PopupMenuControl
520        STRUCT WMPopupAction &pa
521
522        switch( pa.eventCode )
523                case 2: // mouse up
524                        Variable popNum = pa.popNum
525                        String popStr = pa.popStr
526                       
527                        SetDataFolder root:Packages:NIST:Polarization:Cells
528
529                        // based on the selected string, display the right set of inputs
530//                      Print "now I need to display the right set of waves (2D text?) for ",popStr
531
532                        // for the given cell name, if the wave(s) exist, declare them
533                        if(exists("Decay_"+popStr) == 1)
534                                WAVE decay = $("Decay_"+popStr)
535                        else
536                                // if not, make it, and the space for the results of the calculation
537                                MakeDecayResultWaves(popStr)
538                                WAVE decay = $("root:Packages:NIST:Polarization:Cells:Decay_"+popStr)
539                        endif                   
540                        // append matrix, clearing the old one first
541                        SetDataFolder root:Packages:NIST:Polarization:Cells
542
543                        KillWindow DecayPanel#T0
544                        Edit/W=(14,55,794,275)/HOST=DecayPanel
545                        RenameWindow #,T0
546                        AppendtoTable/W=DecayPanel#T0 decay.ld                  //show the labels
547                        ModifyTable width(Point)=0
548                        ModifyTable width(decay.l)=20
549                       
550                        SetActiveSubwindow ##
551       
552                        SetDataFolder root:
553                       
554                        break
555                case -1: // control being killed
556                        break
557        endswitch
558
559        return 0
560End
561
562Function MakeDecayResultWaves(popStr)
563        String popStr
564
565        SetDataFolder root:Packages:NIST:Polarization:Cells
566
567        Make/O/D/N=(1,8) $("Decay_"+popStr)
568        WAVE decay = $("Decay_"+popStr)
569        // set the column labels
570        SetDimLabel 1,0,Trans_He_In,decay
571        SetDimLabel 1,1,Trans_He_Out,decay
572        SetDimLabel 1,2,Blocked,decay
573        SetDimLabel 1,3,mu_star,decay
574        SetDimLabel 1,4,Pol_Cell,decay
575        SetDimLabel 1,5,T_Major,decay
576        SetDimLabel 1,6,Include,decay                   //for a mask wave, non-zero is used in the fit
577        SetDimLabel 1,7,elapsed_hr,decay
578        decay[0][6] = 1                 //default to include the point
579       
580        // generate the dummy wave note now, change as needed
581        Note decay, "muP=2,err_muP=0,P0=0.6,err_P0=0,T0=asdf,gamma=200,err_gamma=0,"
582       
583        // to hold the results of the calculation
584        Make/O/D/N=(1,14) $("DecayCalc_"+popStr)
585        WAVE decayCalc = $("DecayCalc_"+popStr)
586        SetDimLabel 1,0,CR_Trans_He_In,decayCalc
587        SetDimLabel 1,1,err_CR_Trans_He_In,decayCalc
588        SetDimLabel 1,2,CR_Trans_He_Out,decayCalc
589        SetDimLabel 1,3,err_CR_Trans_He_Out,decayCalc
590        SetDimLabel 1,4,CR_Blocked,decayCalc
591        SetDimLabel 1,5,err_CR_Blocked,decayCalc
592        SetDimLabel 1,6,muPo,decayCalc
593        SetDimLabel 1,7,err_muPo,decayCalc
594        SetDimLabel 1,8,Po,decayCalc
595        SetDimLabel 1,9,err_Po,decayCalc
596        SetDimLabel 1,10,Tmaj,decayCalc
597        SetDimLabel 1,11,err_Tmaj,decayCalc
598        SetDimLabel 1,12,gamm,decayCalc
599        SetDimLabel 1,13,err_gamm,decayCalc     
600
601        SetDataFolder root:
602
603        return(0)
604End
605
606
607// since the "Decay_" table can be edited directly to increase the number of rows, it is tough
608// to increase the number of rows in the "DecayCalc_" wave and keep them in sync.
609//
610// --so make sure that the sizes match, and do them all
611//
612Function CalcRowParamButton(ba) : ButtonControl
613        STRUCT WMButtonAction &ba
614
615        Variable selRow,err=0
616        String fname, t0str, cellStr,noteStr,t1Str
617
618        switch( ba.eventCode )
619                case 2: // mouse up
620                        // click code here
621                        Variable cr1,cr2,cr3,err_cr1,err_cr2,err_cr3
622                        Variable muPo,err_muPo,Po,err_Po,Pcell,err_Pcell,Tmaj,err_Tmaj
623                        //Variable Te,err_Te,mu,err_mu
624                               
625                        ControlInfo/W=DecayPanel popup_0
626                        cellStr = S_Value
627                        WAVE w=$("root:Packages:NIST:Polarization:Cells:Decay_"+cellStr)                //the one that is displayed
628                        WAVE calc=$("root:Packages:NIST:Polarization:Cells:DecayCalc_"+cellStr)         // behind the scenes
629                       
630                        Variable numRows,ncalc,diff
631                        numRows = DimSize(w,0)          //rows in the displayed table
632                        ncalc = DimSize(calc,0)
633                       
634                        // add rows to the DecayCalc_ matrix as needed
635                        if(numRows != ncalc)
636                                if(ncalc > numRows)
637                                        DoAlert 0,"The DecayCalc_ is larger than displayed. Seek help."
638                                        err = 1
639                                        return(err)
640                                else
641                                        diff = numRows - ncalc
642                                        InsertPoints/M=0 ncalc, diff, calc
643                                endif
644                        endif
645                       
646                       
647//                      GetSelection table, DecayPanel#T0, 1
648//                      selRow = V_startRow
649
650                        Variable sum_muP, err_avg_muP, sum_Po, err_avg_Po, avg_muP, avg_Po
651                        sum_muP = 0
652                        sum_Po = 0
653                        err_avg_muP = 0
654                        err_avg_Po = 0
655                       
656                        for(selRow=0;selRow<numRows;selRow+=1)
657                                Print "calculate the row ",selRow
658
659                                if(selRow == 0)
660                                        //find T0
661                                        fname = FindFileFromRunNumber(w[0][%Trans_He_In])
662                                        t0str = getFileCreationDate(fname)
663                                        SVAR gT0 = root:Packages:NIST:Polarization:Cells:gT0
664                                        gT0 = t0Str             //for display
665                                        noteStr = note(w)
666                                        noteStr = ReplaceStringByKey("T0", noteStr, gT0  ,"=", ",", 0)
667                                        Note/K w
668                                        Note w, noteStr
669                                        Print t0str
670                                        w[selRow][%elapsed_hr] = 0                      //by definition
671                                endif
672                               
673                                // parse the rows, report errors (there, not here), exit if any found
674                                err = ParseDecayRow(w,selRow)
675                                if(err)
676                                        return 0
677                                endif
678                               
679                                // do the calculations:
680                                // 1 for each file, return the count rate and err_CR (normalize to atten or not)
681       
682                                Print "The Blocked CR is not rescaled to zero attenuators"
683                                cr1 = TotalCR_FromRun(w[selRow][%Trans_He_In],err_cr1,0)
684                                cr2 = TotalCR_FromRun(w[selRow][%Trans_He_Out],err_cr2,0)
685                                cr3 = TotalCR_FromRun(w[selRow][%Blocked],err_cr3,1)                    //blocked beam is NOT normalized to zero attenuators
686                               
687                                calc[selRow][%CR_Trans_He_In] = cr1
688                                calc[selRow][%CR_Trans_He_Out] = cr2
689                                calc[selRow][%CR_Blocked] = cr3
690                                calc[selRow][%err_cr_Trans_He_In] = err_cr1
691                                calc[selRow][%err_cr_Trans_He_Out] = err_cr2
692                                calc[selRow][%err_cr_Blocked] = err_cr3
693       
694       
695                                // 2 find the mu and Te values for cellStr
696                                SVAR gCellKW = $("root:Packages:NIST:Polarization:Cells:gCell_"+cellStr)
697                                //(moved to a separate function, just pass the string)
698        //                      Te = NumberByKey("Te", gCellKW, "=", ",", 0)
699        //                      err_Te = NumberByKey("err_Te", gCellKW, "=", ",", 0)
700        //                      mu = NumberByKey("mu", gCellKW, "=", ",", 0)
701        //                      err_mu = NumberByKey("err_mu", gCellKW, "=", ",", 0)
702        //                     
703                                // 3 Calc muPo and error
704                                muPo = Calc_muPo(calc,gCellKW,selRow,err_muPo)
705                                calc[selRow][%muPo] = muPo
706                                calc[selRow][%err_muPo] = err_muPo
707                                w[selRow][%mu_star] = muPo
708                               
709                                // 3.5 calc Polarization of cell (no value or error stored in calc wave?)
710                                PCell = Calc_PCell(muPo,err_muPo,err_PCell)
711        //                      PCell = Calc_PCell(2,err_muPo,err_PCell)
712                                w[selRow][%Pol_Cell] = PCell
713       
714                                // 4 calc Po and error
715                                Po = Calc_Po(gCellKW,muPo,err_muPo,err_Po)
716        //                      Po = Calc_Po(gCellKW,2,err_muPo,err_Po)
717                                calc[selRow][%Po] = Po
718                                calc[selRow][%err_Po] = err_Po
719                               
720                                // 5 calc Tmaj and error
721                                Tmaj = Calc_Tmaj(gCellKW,Po,err_Po,err_Tmaj)
722                                calc[selRow][%Tmaj] = Tmaj
723                                calc[selRow][%err_Tmaj] = err_Tmaj
724                                w[selRow][%T_major] = Tmaj
725                               
726                                // elapsed hours
727                                fname = FindFileFromRunNumber(w[selRow][%Trans_He_In])
728                                t1str = getFileCreationDate(fname)
729                                w[selRow][%elapsed_hr] = ElapsedHours(t0Str,t1Str)
730                               
731                                // running average of muP and Po
732                                sum_muP += muPo
733                                sum_Po += Po
734                                err_avg_muP += err_muPo^2
735                                err_avg_Po += err_Po^2
736                               
737                        endfor          //loop over rows
738                       
739                        // now get a running average of muP, Po, and the errors
740                        avg_muP = sum_muP/numRows
741                        avg_Po = sum_Po/numRows
742                        err_avg_muP = sqrt(err_avg_muP) / numRows
743                        err_avg_Po = sqrt(err_avg_Po) / numRows
744                       
745//                      str = "muP=2,err_muP=0,P0=0.6,err_P0=0,T0=asdf,gamma=200,err_gamma=0,"
746
747                        // Don't put the average values into the wave note, but rather the results of the fit
748//                      noteStr = note(w)
749//                      noteStr = ReplaceNumberByKey("muP", noteStr, avg_muP ,"=", ",", 0)
750//                      noteStr = ReplaceNumberByKey("P0", noteStr, avg_Po ,"=", ",", 0)
751//                      noteStr = ReplaceNumberByKey("err_muP", noteStr, err_avg_muP ,"=", ",", 0)
752//                      noteStr = ReplaceNumberByKey("err_P0", noteStr, err_avg_Po ,"=", ",", 0)
753//                     
754//                      // replace the string
755//                      Note/K w
756//                      Note w, noteStr
757                                       
758                        Printf "Average muP = %g +/- %g (%g%)\r",avg_muP,err_avg_muP,err_avg_muP/avg_muP*100
759                        Printf "Average Po = %g +/- %g (%g%)\r",avg_Po,err_avg_Po,err_avg_Po/avg_Po*100
760                       
761                        //update the global values for display (not these, but after the fit)
762//                      Print " -- need to add the error to the display on the panel    "
763//                      NVAR gMuPo = root:Packages:NIST:Polarization:Cells:gMuPo
764//                      NVAR gPo  = root:Packages:NIST:Polarization:Cells:gPo
765//                      gMuPo = avg_muP
766//                      gPo = avg_Po
767                       
768                        break
769                case -1: // control being killed
770                        break
771        endswitch
772
773        return 0
774End
775
776
777// calculate Tmaj and its error
778Function Calc_Tmaj(cellStr,Po,err_Po,err_Tmaj)
779        String cellStr
780        Variable Po,err_Po,&err_Tmaj
781       
782        Variable Tmaj,arg
783        Variable Te,err_Te,mu,err_mu
784// cell constants       
785        Te = NumberByKey("Te", cellStr, "=", ",", 0)
786        err_Te = NumberByKey("err_Te", cellStr, "=", ",", 0)
787        mu = NumberByKey("mu", cellStr, "=", ",", 0)
788        err_mu = NumberByKey("err_mu", cellStr, "=", ",", 0)
789       
790        Tmaj = Te*exp(-mu*(1-Po))
791       
792        //the error
793        err_Tmaj = (Tmaj/Te)^2*err_Te^2 + (Tmaj*(1-Po))^2*err_mu^2 + (Tmaj*mu)^2*err_Po^2
794        err_Tmaj = sqrt(err_Tmaj)
795       
796        Printf "Tmaj = %g +/- %g (%g%)\r",Tmaj,err_Tmaj,err_Tmaj/Tmaj*100
797
798       
799        return(Tmaj)
800End
801
802
803// calculate PCell and its error
804//
805//
806Function Calc_PCell(muPo,err_muPo,err_PCell)
807        Variable muPo,err_muPo,&err_PCell
808       
809        Variable PCell,arg
810
811        PCell = tanh(muPo)
812       
813        // error (single term, sqrt already done)
814        err_Pcell = (1 - (tanh(muPo))^2) * err_muPo
815       
816        Printf "Pcell = %g +/- %g (%g%)\r",Pcell,err_Pcell,err_Pcell/PCell*100
817
818        return(PCell)
819End
820
821// calculate Po and its error
822Function Calc_Po(cellStr,muPo,err_muPo,err_Po)
823        String cellStr
824        Variable muPo,err_muPo,&err_Po
825       
826        Variable Po,tmp
827        Variable mu,err_mu
828// cell constants       
829        mu = NumberByKey("mu", cellStr, "=", ",", 0)
830        err_mu = NumberByKey("err_mu", cellStr, "=", ",", 0)
831       
832        Po = muPo/mu
833       
834        tmp = (err_muPo/muPo)^2 + (err_mu/mu)^2
835        err_Po = Po * sqrt(tmp)
836       
837        Printf "Po = %g +/- %g (%g%)\r",Po,err_Po,err_Po/Po*100
838        return(Po)
839End
840
841// calculate muPo and its error
842Function Calc_muPo(calc,cellStr,selRow,err_muPo)
843        Wave calc
844        String cellStr
845        Variable selRow,&err_muPo
846       
847        Variable muPo,arg
848        Variable Te,err_Te,mu,err_mu
849// cell constants       
850        Te = NumberByKey("Te", cellStr, "=", ",", 0)
851        err_Te = NumberByKey("err_Te", cellStr, "=", ",", 0)
852        mu = NumberByKey("mu", cellStr, "=", ",", 0)
853        err_mu = NumberByKey("err_mu", cellStr, "=", ",", 0)
854       
855        Variable cr1,cr2,cr3,err_cr1,err_cr2,err_cr3
856        // cr1 is He in, 2 is He out, 3 is blocked
857        cr1      =      calc[selRow][%CR_Trans_He_In]
858        cr2 =   calc[selRow][%CR_Trans_He_Out]
859        cr3 =   calc[selRow][%CR_Blocked]
860        err_cr1 =       calc[selRow][%err_cr_Trans_He_In]
861        err_cr2 =       calc[selRow][%err_cr_Trans_He_Out]
862        err_cr3 =       calc[selRow][%err_cr_Blocked]
863       
864        muPo = acosh( (cr1 - cr3)/(cr2 - cr3) * (1/(Te*exp(-mu))) )
865       
866        Variable arg_err, tmp1, tmp2
867        // the error is a big mess to calculate, since it's messy argument inside acosh
868        arg = (cr1 - cr3)/(cr2 - cr3) * (1/(Te*exp(-mu)))
869        tmp2 =  (1/sqrt(arg+1)/sqrt(arg-1))^2                                   // derivative of acosh(arg) (squared)
870       
871        // calculate the error of the argument first, then the error of acosh(arg)
872        // there are 5 partial derivatives
873        arg_err = tmp2 * ( arg/(cr1 - cr3) * err_cr1 )^2                //CR in
874        arg_err += tmp2 * ( arg/(cr2 - cr3) * err_cr2 )^2       //CR out
875        arg_err += tmp2 * ((-arg/(cr1 - cr3) +  arg/(cr2 - cr3) )* err_cr3 )^2//CR bkg
876        arg_err += tmp2 * ( -arg/Te * err_Te )^2                                        //Te
877        arg_err += tmp2 * ( arg * err_mu )^2                                            //mu  (probably the dominant relative error)
878       
879        err_muPo = sqrt(arg_err)
880       
881       
882        return(muPo)
883End
884
885
886//Function testCR(num)
887//      Variable num
888//      Variable err_cr
889//     
890//      Variable noNorm=0
891//      Variable cr = TotalCR_FromRun(num,err_cr,noNorm)
892//      printf "CR = %g +/- %g (%g%)\r",cr,err_cr,err_cr/cr*100
893//      return(0)
894//End
895
896// calculate the total detector CR ane its error.
897//
898// the result is automatically normalized to 10^8 monitor counts, and to zero attenuators
899//
900// if noNorm = 1, then the normalization to attenuators is not done
901//
902Function TotalCR_FromRun(num,err_cr,noNorm)
903        Variable num,&err_cr,noNorm
904
905        String fname="",instr="",tmpStr=""
906        Variable cr,cts,err_cts,ctTime,monCts,attenNo,lambda,attenTrans,atten_err
907       
908        fname = FindFileFromRunNumber(num)
909        cts = getDetCount(fname)
910        err_cts = sqrt(cts)
911       
912        ctTime = getCountTime(fname)
913        monCts = getMonitorCount(fname)
914        attenNo = getAttenNumber(fname)
915        instr = getAcctName(fname)              //this is 11 characters
916        lambda = getWavelength(fname)
917        attenTrans = AttenuationFactor(instr,lambda,AttenNo,atten_err)
918       
919        if(noNorm==1)                   //don't normalize to attenuation
920                attenTrans=1
921                atten_err=0
922        endif
923        cr = cts/ctTime*1e8/monCts/attenTrans
924        err_cr = cr * sqrt(err_cts^2/cts^2 + atten_err^2/attenTrans^2)
925       
926        printf "CR = %g +/- %g (%g%)\r",cr,err_cr,err_cr/cr*100
927
928               
929        return(cr)
930end
931
932
933// input is VAX date and time string, t1 later than t0
934//
935Function ElapsedHours(t0Str,t1Str)
936        String t0Str,t1Str
937       
938        Variable t0,t1,elapsed
939       
940        t0 = ConvertVAXDateTime2Secs(t0Str)             //seconds
941        t1 = ConvertVAXDateTime2Secs(t1Str)
942       
943        elapsed = t1-t0
944        elapsed /= 3600                 //convert to hours
945       
946        return(elapsed)
947End
948
949// bring up a table with the calculation results
950Function ShowCalcRowButton(ba) : ButtonControl
951        STRUCT WMButtonAction &ba
952
953        switch( ba.eventCode )
954                case 2: // mouse up
955                        // click code here
956                        ControlInfo/W=DecayPanel popup_0
957                        String cellStr = S_Value
958                        WAVE calc=$("root:Packages:NIST:Polarization:Cells:DecayCalc_"+cellStr)         //the one that is displayed
959                        edit calc.ld
960                                               
961                        break
962                case -1: // control being killed
963                        break
964        endswitch
965
966        return 0
967End
968
969
970Function DecayFitButtonProc(ba) : ButtonControl
971        STRUCT WMButtonAction &ba
972
973        String cellStr=""
974        Variable num
975
976        switch( ba.eventCode )
977                case 2: // mouse up
978                        // click code here
979
980                        ControlInfo/W=DecayPanel popup_0
981                        cellStr = S_Value
982                       
983                        SetDataFolder root:Packages:NIST:Polarization:Cells:
984                       
985                        WAVE decay=$("Decay_"+cellStr)          //the one that is displayed
986                        WAVE calc=$("DecayCalc_"+cellStr)               //the one that is displayed
987                       
988//                      make temp copies for the fit and plot, extra for mask
989                        num = DimSize(calc,0)
990                        Make/O/D/N=(num)                tmp_Mask,tmp_hr,tmp_muP,tmp_err_muP,tmp_muP2
991                       
992                        tmp_Mask = decay[p][%Include]
993                        tmp_hr = decay[p][%elapsed_hr]
994                        tmp_muP = calc[p][%muPo]
995                        tmp_muP2 = tmp_muP
996                        tmp_err_muP = calc[p][%err_muPo]
997                       
998                        tmp_muP2 = (tmp_Mask == 1) ? NaN : tmp_muP2                     //only excluded points will plot
999                       
1000                        // clear old data, and plot the new
1001                        //
1002                        CheckDisplayed/W=DecayPanel#G0 tmp_muP,tmp_muP2,fit_tmp_muP
1003                        // if both present, bit 0 + bit 1 = 3
1004                        if(V_flag & 2^0)                        //check bit 0
1005                                RemoveFromGraph/W=DecayPanel#G0 tmp_muP
1006                        endif
1007                        if(V_flag & 2^1)
1008                                RemoveFromGraph/W=DecayPanel#G0 tmp_muP2
1009                        endif
1010                        if(V_flag & 2^2)
1011                                RemoveFromGraph/W=DecayPanel#G0 fit_tmp_muP
1012                        endif
1013                       
1014                        AppendToGraph/W=DecayPanel#G0 tmp_muP vs tmp_hr
1015                        AppendToGraph/W=DecayPanel#G0 tmp_muP2 vs tmp_hr
1016
1017                        ModifyGraph/W=DecayPanel#G0 log(left)=1
1018                        ModifyGraph/W=DecayPanel#G0 frameStyle=2
1019                        ModifyGraph/W=DecayPanel#G0 mode=3
1020                        ModifyGraph/W=DecayPanel#G0 marker=19
1021                        ModifyGraph/W=DecayPanel#G0 rgb(tmp_muP)=(1,16019,65535),rgb(tmp_muP2)=(65535,0,0)
1022                        ModifyGraph/W=DecayPanel#G0 msize=3
1023                        ErrorBars/W=DecayPanel#G0 tmp_muP,Y wave=(tmp_err_muP,tmp_err_muP)
1024                       
1025                        Label/W=DecayPanel#G0 left "mu*P"
1026                        Label/W=DecayPanel#G0 bottom "time (h)"
1027                       
1028// do the fit
1029//       as long as the constant X0 doesn't stray from zero, exp_XOffset is OK, otherwise I'll need to switch to the exp function
1030
1031                        SetActiveSubwindow DecayPanel#G0                        //to get the automatic fit to show up on the graph
1032
1033//                      Make/O/D/N=3 fitCoef={0,5,0.05}
1034//                      CurveFit/H="100"/M=2/W=0/TBOX=(0x310) exp_XOffset, kwCWave=fitCoef, tmp_muP /X=tmp_hr /D /I=1 /W=tmp_err_muP /M=tmp_Mask
1035
1036
1037                        Make/O/D/N=3 fitCoef={0,5,0.05}
1038                        CurveFit/H="100"/M=2/W=0/TBOX=(0x310) exp, kwCWave=fitCoef, tmp_muP /X=tmp_hr /D /I=1 /W=tmp_err_muP /M=tmp_Mask
1039                       
1040
1041                        SetActiveSubwindow ##
1042                       
1043                       
1044// then report and save the results
1045//                      the exp function => y = y0 + A*exp(-Bx)
1046//                      W_coef[0] = y0 should be close to zero (or fixed at zero)
1047//                      W_coef[1] = A should be close to the initial muP value
1048//                      W_coef[2] = B is 1/Gamma
1049//                      WAVE W_coef=W_coef
1050                        WAVE W_sigma=W_sigma
1051                        Variable gamma_val,err_gamma,muPo, err_muPo, Po, err_Po
1052                        String noteStr=""
1053       
1054                        SVAR gCellKW = $("root:Packages:NIST:Polarization:Cells:gCell_"+cellStr)       
1055                        SVAR gGamma  = root:Packages:NIST:Polarization:Cells:gGamma
1056                        SVAR gMuPo = root:Packages:NIST:Polarization:Cells:gMuPo
1057                        SVAR gPo  = root:Packages:NIST:Polarization:Cells:gPo
1058                       
1059                        muPo = fitCoef[1]
1060                        err_muPo = W_sigma[1]
1061                       
1062                        Po = Calc_Po(gCellKW,muPo,err_muPo,err_Po)
1063
1064                        // if exp_XOffset used
1065//                      gGamma = fitCoef[2]
1066//                      err_Gamma = W_sigma[2]
1067
1068                        // calculating the error using exp is the inverse of coef[2]:
1069                        gamma_val  = 1/fitCoef[2]
1070                        err_gamma = W_sigma[2]/(fitCoef[2])^2
1071               
1072                       
1073//              for the wave note
1074                        noteStr = note(decay)
1075                        noteStr = ReplaceNumberByKey("muP", noteStr, MuPo ,"=", ",", 0)
1076                        noteStr = ReplaceNumberByKey("P0", noteStr, Po ,"=", ",", 0)
1077                        noteStr = ReplaceNumberByKey("err_muP", noteStr, err_muPo ,"=", ",", 0)
1078                        noteStr = ReplaceNumberByKey("err_P0", noteStr, err_Po ,"=", ",", 0)
1079                        noteStr = ReplaceNumberByKey("gamma", noteStr, gamma_val ,"=", ",", 0)
1080                        noteStr = ReplaceNumberByKey("err_gamma", noteStr, err_gamma ,"=", ",", 0)
1081
1082                        // replace the string
1083                        Note/K decay
1084                        Note decay, noteStr
1085                       
1086                       
1087                        // for the panel display
1088                        sprintf gMuPo, "%g +/- %g",fitCoef[1],W_sigma[1]
1089                        sprintf gPo, "%g +/- %g",Po,err_Po
1090                        sprintf gGamma, "%g +/- %g",gamma_val,err_gamma
1091
1092                       
1093                       
1094                        SetDataFolder root:
1095                       
1096                        break
1097                case -1: // control being killed
1098                        break
1099        endswitch
1100
1101        return 0
1102End
1103
1104
1105// clear just the row
1106//
1107Function ClearDecayWavesRowButton(ba) : ButtonControl
1108        STRUCT WMButtonAction &ba
1109
1110        String popStr=""
1111        Variable selRow
1112       
1113        switch( ba.eventCode )
1114                case 2: // mouse up
1115                        // click code here
1116                        DoAlert 1,"Clear the selected row?"
1117                        if(V_flag !=1)
1118                                return(0)
1119                        endif
1120                       
1121                        SetDataFolder root:Packages:NIST:Polarization:Cells
1122
1123                        ControlInfo/W=DecayPanel popup_0
1124                        popStr = S_Value
1125                       
1126                        Wave decay = $("Decay_"+popStr)
1127                        Wave calc = $("DecayCalc_"+popStr)
1128
1129                        // Delete just those points
1130                                               
1131                        GetSelection table, DecayPanel#T0, 1
1132                        selRow = V_startRow
1133                        DeletePoints selRow,1,decay,calc                       
1134                       
1135                        // clear the graph and the results                     
1136                        NVAR gMuPo = root:Packages:NIST:Polarization:Cells:gMuPo
1137                        NVAR gPo  = root:Packages:NIST:Polarization:Cells:gPo
1138                        NVAR gGamma  = root:Packages:NIST:Polarization:Cells:gGamma
1139                        SVAR gT0  = root:Packages:NIST:Polarization:Cells:gT0
1140                        gMuPo = 0
1141                        gPo = 0
1142                        gGamma = 0
1143                        gT0 = "recalculate"
1144                       
1145                       
1146                        SetDataFolder root:
1147                        break
1148                case -1: // control being killed
1149                        break
1150        endswitch
1151
1152        return 0
1153End
1154
1155
1156
1157// for this, do I want to clear everything, or just a selected row??
1158//
1159//
1160Function ClearDecayWavesButton(ba) : ButtonControl
1161        STRUCT WMButtonAction &ba
1162
1163        String popStr=""
1164       
1165        switch( ba.eventCode )
1166                case 2: // mouse up
1167                        // click code here
1168                        DoAlert 1,"Clear all of the decay waves for the selected cell?"
1169                        if(V_flag !=1)
1170                                return(0)
1171                        endif
1172                       
1173                        SetDataFolder root:Packages:NIST:Polarization:Cells
1174
1175                        ControlInfo/W=DecayPanel popup_0
1176                        popStr = S_Value
1177                       
1178                        Wave decay = $("Decay_"+popStr)
1179                        Wave calc = $("DecayCalc_"+popStr)
1180                       
1181//                      re-initialize the decay waves, so it appears as a blank, initialized table
1182
1183                        MakeDecayResultWaves(popStr)
1184                        decay = 0
1185                        calc = 0
1186       
1187                        // clear the graph and the results?     
1188                       
1189                       
1190                                       
1191                        NVAR gMuPo = root:Packages:NIST:Polarization:Cells:gMuPo
1192                        NVAR gPo  = root:Packages:NIST:Polarization:Cells:gPo
1193                        NVAR gGamma  = root:Packages:NIST:Polarization:Cells:gGamma
1194                        SVAR gT0  = root:Packages:NIST:Polarization:Cells:gT0
1195                        gMuPo = 0
1196                        gPo = 0
1197                        gGamma = 0
1198                        gT0 = "recalculate"
1199                       
1200                       
1201                        SetDataFolder root:
1202                        break
1203                case -1: // control being killed
1204                        break
1205        endswitch
1206
1207        return 0
1208End
1209
1210
1211Function DecayHelpParButtonProc(ba) : ButtonControl
1212        STRUCT WMButtonAction &ba
1213
1214        switch( ba.eventCode )
1215                case 2: // mouse up
1216                        // click code here
1217                        DoAlert 0,"Help for Cell Decay Panel not written yet"
1218                        break
1219                case -1: // control being killed
1220                        break
1221        endswitch
1222
1223        return 0
1224End
1225
1226// E=-5 is a PNG, =8 is PDF
1227// there are other options to do EPS, embed fonts, etc.
1228//
1229Function WindowSnapshotButton(ba) : ButtonControl
1230        STRUCT WMButtonAction &ba
1231
1232        switch( ba.eventCode )
1233                case 2: // mouse up
1234                        // click code here
1235                        SavePICT /E=-5/SNAP=1
1236                        break
1237                case -1: // control being killed
1238                        break
1239        endswitch
1240
1241        return 0
1242End
1243
1244// null condition is not right. if the loop fails, then the
1245// retStr will be ";;;;", not zero length. What's the proper test?
1246// Does it matter? the list of default gCell_sss should already be there.
1247//
1248Function/S D_CellNameList()
1249
1250        String retStr="",listStr,item
1251        Variable num,ii
1252       
1253        SetDataFolder root:Packages:NIST:Polarization:Cells
1254
1255        // get a list of the cell strings
1256        listStr=StringList("gCell_*",";")
1257        num=ItemsInList(listStr,";")
1258//      print listStr
1259       
1260        // parse the strings to fill the table
1261        for(ii=0;ii<num;ii+=1)
1262                item = StringFromList(ii, listStr,";")
1263                SVAR gStr = $item
1264                retStr += StringByKey("cell", gStr, "=", ",", 0) + ";"
1265        endfor
1266       
1267        if(strlen(retStr) == 0)
1268                retStr = "no cells defined;"
1269        endif
1270       
1271        SetDataFolder root:             
1272        return(retStr)
1273End
1274
1275
1276// parse the row to be sure that:
1277//
1278// - files are valid numbers
1279// - files are all at same SDD
1280// - files are all with same attenuation (just print a warning to cmd)
1281//
1282Function ParseDecayRow(w,selRow)
1283        Wave w
1284        Variable selRow
1285       
1286        Variable err=0, atten1,atten2,atten3,sdd1,sdd2,sdd3
1287        String fname=""
1288        // are all file numbers valid?
1289        fname = FindFileFromRunNumber(w[selRow][%Trans_He_In])
1290        if(cmpstr(fname,"")==0)
1291                DoAlert 0,"Trans_He_In run "+num2str(w[selRow][%Trans_He_In])+" is not a valid run number"
1292                err = 1
1293        else
1294                atten1 = getAttenNumber(fname)
1295                sdd1 = getSDD(fname)
1296        endif
1297       
1298        fname = FindFileFromRunNumber(w[selRow][%Trans_He_Out])
1299        if(cmpstr(fname,"")==0)
1300                DoAlert 0,"Trans_He_Out run "+num2str(w[selRow][%Trans_He_Out])+" is not a valid run number"
1301                err = 1
1302        else
1303                atten2 = getAttenNumber(fname)
1304                sdd2 = getSDD(fname)
1305        endif
1306       
1307        fname = FindFileFromRunNumber(w[selRow][%Blocked])
1308        if(cmpstr(fname,"")==0)
1309                DoAlert 0,"Blocked run "+num2str(w[selRow][%Blocked])+" is not a valid run number"
1310                err = 1
1311        else
1312                atten3 = getAttenNumber(fname)
1313                sdd3 = getSDD(fname)
1314        endif
1315       
1316        if( (sdd1 != sdd2) || (sdd2 != sdd3) || (sdd1 != sdd3) )
1317                DoAlert 0,"Files in row "+num2str(selRow)+" are not all at the same detector distance"
1318                err = 1
1319        endif
1320       
1321        if( (atten1 != atten2) || (atten2 != atten3) || (atten1 != atten3) )
1322                DoAlert 0,"Files in row "+num2str(selRow)+" are not all collected with the same attenuation. Just so you know."
1323                err = 0
1324        endif
1325       
1326        return(err)
1327end
1328
1329
1330////////////////////////////////////////////
Note: See TracBrowser for help on using the repository browser.