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

#pragma rtGlobals=1             // Use modern global access method.
#pragma IgorVersion=6.1



// **** search for TODO to find items still to be fixed in other procedures  **********

// TODO:
// x- on the decay panel. need to be able to manually enter a date that is to or an offset
//              number of hours. currently it takes the first file as t=0, which is often not correct
//


// Polarized Beam Reduction Procedures
//
//
// input panels to set and calculate polarization parameters necessary for the 
// matrix corrections to the cross sections
//
// -1- Fundamental Cell Parameters -- these are constants, generally not editable. (this file)
// -2- Decay Parameters -- these are fitted values based on transmission mearurements (this file)
// -3- Flipper Panel is in its own procedure (Pol_FlipperPanel.ipf)
// -4- PolCor_Panel is in Pol_PolarizationCorrection.ipf
//
//
// Driven by 4 panels to get the necessary information from the users
// -1- Fundamental cell parameters: root:Packages:NIST:Polarization:Cells
//              - default cell parameters are loaded. More cell definitions can be added as more cells are used
//              - changes are saved per experiment
//              - important parameters are held in global key=value strings gCell_<name> 
//              - cell names and parameters are used by the 2nd panel for calculation of the Decay constant
//
// -2- Decay Constant Panel
//              - decay constant determined for each cell.
//              - popping the cell name makes 2 waves, Decay_<cellname> and DecayCalc_<cellname>
//              - Decay_ is the wave presented in the table. Specified transmission run numbers are entered
//                      and "Calc Sel Row" does the calculation of mu and Pcell (for all rows, actually)
//              - DimLabels are used for the arrays to make the column identity more readable than simply an index
//              - time=0 is taken from the first file
//              - Calculations are based on the count rate of the file, corrected for monitor and attenuation
//              - alerts are posted for files in any row that are not at the same attenuation or SDD
//              - if "include" column is == 1, that row will be included in the fit of the decay data
//              - excluded points are plotted in red
//              - results of the fit are printed on the panel, and written to the wave note of the Decay_ wave 
//                      (not DecayCalc_) for use in the next panel
//              - manual entry of all of the parameters in the wave note is allowed.
//
//
// -3- Flipper Panel (not in this procedure - in Pol_FlipperPanel.ipf)
//              - calculates the flipper and supermirror efficiencies for a given "condition"
//              - this "condition" may have contributions from multiple cells
//              - start by entering a condition name
//              - Waves Cond_<condition> and CondCalc_<condition>, and CondCell are created
//              - DimLabels are used for the arrays to make the column identity more readable than simply an index
//              - Enter the name of the cell in the first column (the cell must be defined and decay calculated)
//              - enter transmission run numbers as specified in the table
//              - Do Average will calculate the Psm and PsmPfl values (and errors) and average if more than
//                      one row of data is present (and included)
//              - results are printed on the panel, and written to the wave note of Cond_<condition>
//              - results are used in the calculation of the polarization matrix
//              - (the cell name is not entered using a contextual menu, since this is difficult for a subwindow)
//              - (the wave note no longer needs the cell name)
//
// -4- PolCor_Panel (not in this procedure - in Pol_PolarizationCorrection.ipf)
//              - gets all of the parameters from the user to do the polariztion correction, then the "normal" SANS reduction
//              - up to 10 files can be added together for each of the different spin states (more than this??)
//              - one polarization condition is set for everything with the popup @ the top
//              - two-column list boxes for each state hold the run number and the cell name
//              - the same list boxes are duplicated (hidden) for the SAM/EMP/BGD tabs as needed
//              - on loading of the data, the 2-letter spin state is tagged onto the loaded waves (all of them)
//              - displayed data is simply re-pointed to the desired data
//              - on loading, the raw files are added together as ususal, normalized to monitor counts. Then each contribution 
//                      of the file to the polarization matrix is added (scaling each by mon/1e8)
//              - loaded data and PolMatrix are stored in the ususal SAM, EMP, BGD folders.
//              - Polarization correction is done with one click (one per tab). "_pc" tags are added to the resulting names,
//                      and copies of all of the associated waves are again copied (wasteful), but makes switching display very easy
//              - Once all of the polarization correction is done, then the UU_pc (etc.) data can be reduced as usual (xx_pc = 4 passes)
//              - protocol is built as ususal, from this panel only (since the SAM, EMP, and BGD need to be switched, rather than loaded
//              - protocols can be saved/recalled.
//              - reduction will always ask for a protocol rather than using what's on the panel.
//              - closing the panel will save the state (except the protocol). NOT initializing when re-opening will restore the 
//                      state of the entered runs and the popups of conditions.
//
//
//
//



// for the menu
Menu "Macros"
        "Flipping Ratio",ShowFlippingRatioPanel()
        "1 Fundamental Cell Parameters",ShowCellParamPanel()
        "2 Cell Decay",ShowCellDecayPanel()
        "3 Flipper States",ShowFlipperPanel()
        "4 Polarization Correction",ShowPolCorSetup()
        "-"
        Submenu "Save State of..."
                "Fundamental Cell Parameters",SaveCellParameterTable()
                "Cell Decay Panel",SaveCellDecayTable()
                "Flipper Condition Panel",SaveFlipperTable()
                "Polarization Correction Panel",SavePolCorPanelState()
        End
        Submenu "Restore State of..."
                "Fundamental Cell Parameters",RestoreCellParameterTable()
                "Cell Decay Panel",RestoreCellDecayTable()
                "Flipper Condition Panel",RestoreFlipperTable()
                "Polarization Correction Panel",RestorePolCorPanelState()
        End
End


//
// Panel -1-
//
// Fundamental He cell parameters. Most of these are pre-defined, so that they are supplied as a 
// static table, only edited as parameters are refined.
//
// work with this as kwString
// cell=nameStr
// lambda=num
// Te=num
// err_Te=num
// mu=num
// err_mu=num
//
//
// for this panel, the cell parameters are stored as kw strings
// all of the strings start w/ "gCell_"
//
Proc ShowCellParamPanel()
        
        // init folders
        // ASK before initializing cell constants
        // open the panel
        DoWindow/F CellParamPanel
        if(V_flag == 0)
                InitPolarizationFolders()
                DoAlert 1,"Do you want to use default parameters?"
                if(V_flag == 1)
                        InitPolarizationGlobals()
                endif
                Make_HeCell_ParamWaves()
                DrawCellParamPanel()
        endif
        // be sure that the panel is onscreen
        DoIgorMenu "Control","Retrieve Window"
end

// setup the data folder, etc
//
//
Function InitPolarizationFolders()

        NewDataFolder/O root:Packages:NIST:Polarization
        NewDataFolder/O root:Packages:NIST:Polarization:Cells                   //holds the cell constants and waves
        
        SetDataFolder root:
        return(0)
End

//
// add more cells here as they are defined,
//
// first clear out the list, then rebuild it
//
Function InitPolarizationGlobals()

        SetDataFolder root:Packages:NIST:Polarization:Cells
        
        String listStr=StringList("gCell_*",";"),item
        Variable        ii,num=ItemsInList(listStr,";")

        for(ii=0;ii<num;ii+=1)
                item = StringFromList(ii, listStr,";")
                SVAR gStr = $item
                KillStrings/Z gStr
        endfor
        
        //rebuild the list
        // cell constants
        String/G gCell_Maverick = "cell=Maverick,lambda=5.0,Te=0.87,err_Te=0.01,mu=3.184,err_mu=0.02,"
        String/G gCell_Burgundy = "cell=Burgundy,lambda=5.0,Te=0.86,err_Te=0.01,mu=3.138,err_mu=0.015,"
        String/G gCell_Olaf = "cell=Olaf,lambda=7.5,Te=0.86,err_Te=0.005,mu=2.97,err_mu=0.018,"
        
        
        SetDataFolder root:
        return(0)
End


// parse strings to fill in waves
//
//
Function Make_HeCell_ParamWaves()

        SetDataFolder root:Packages:NIST:Polarization:Cells
        
        String listStr,item
        Variable num,ii
        
        // get a list of the strings
        listStr=StringList("gCell_*",";")
        num=ItemsInList(listStr,";")
        print listStr
        
        Make/O/T/N=0 CellName
        Make/O/D/N=0 lambda,Te,err_Te,mu,err_mu

// when the values are reverted, necessary to get back to zero elements
        Redimension/N=0 CellName
        Redimension/N=0 lambda,Te,err_Te,mu,err_mu
                
        // parse the strings to fill the table
        for(ii=0;ii<num;ii+=1)
                item = StringFromList(ii, listStr,";")
                SVAR gStr = $item
                InsertPoints  ii, 1, CellName,lambda,Te,err_Te,mu,err_mu
                CellName[ii] = StringByKey("cell", gStr, "=", ",", 0)
                lambda[ii] = NumberByKey("lambda", gStr, "=", ",", 0)
                Te[ii] = NumberByKey("Te", gStr, "=", ",", 0)
                err_Te[ii] = NumberByKey("err_Te", gStr, "=", ",", 0)
                mu[ii] = NumberByKey("mu", gStr, "=", ",", 0)
                err_mu[ii] = NumberByKey("err_mu", gStr, "=", ",", 0)
                
        endfor

        
        SetDataFolder root:
        return(0)
End

// take the waves from the table and write these back to the string, only for the current experiment
//
Function Save_HeCell_ParamWaves()

        SetDataFolder root:Packages:NIST:Polarization:Cells
        
        String listStr,item,dummyStr
        Variable num,ii
        
        // get a list of the strings
        listStr=StringList("gCell_*",";")
        num=ItemsInList(listStr,";")
        KillStrings/Z listStr
        
        Wave/T CellName
        Wave lambda,Te,err_Te,mu,err_mu
        
        dummyStr = "cell=Maverick,lambda=5.0,Te=0.87,err_Te=0.01,mu=3.184,err_mu=0.2,"
        
        num=numpnts(CellName)
        
        // parse the table to fill the Strings
        for(ii=0;ii<num;ii+=1)
                item = "gCell_"+CellName[ii]
                String/G $item = dummyStr
                SVAR kwListStr = $item
                
                kwListStr = ReplaceStringByKey("cell", kwListStr, CellName[ii], "=", ",", 0)
                kwListStr = ReplaceNumberByKey("lambda", kwListStr, lambda[ii], "=", ",", 0)
                kwListStr = ReplaceNumberByKey("Te", kwListStr, Te[ii], "=", ",", 0)
                kwListStr = ReplaceNumberByKey("err_Te", kwListStr, err_Te[ii], "=", ",", 0)
                kwListStr = ReplaceNumberByKey("mu", kwListStr, mu[ii], "=", ",", 0)
                kwListStr = ReplaceNumberByKey("err_mu", kwListStr, err_mu[ii], "=", ",", 0)
                
        endfor

        SetDataFolder root:
        return(0)
End


// makes the panel after the waves are generated
//
// allow edits of the cells to update the string values
// add a button to "revert" (with warning)
// add a button to add new cells (insert a new row in the table, then update)
//
Function DrawCellParamPanel()

        SetDataFolder root:Packages:NIST:Polarization:Cells
        
        PauseUpdate; Silent 1           // building window...
        NewPanel /W=(150,44,750,377)/N=CellParamPanel/K=1 as "Fundamental Cell Parameters"
        ModifyPanel cbRGB=(65535,49151,55704)
        ModifyPanel fixedSize=1

//      ShowTools/A
        Button button_0,pos={10,10},size={90,20},proc=AddCellButtonProc,title="Add Cell"
        Button button_1,pos={118,10},size={160,20},proc=SaveCellParButtonProc,title="Update Parameters"
        Button button_2,pos={118,35},size={130,20},proc=RevertCellParButtonProc,title="Revert Parameters"
        Button button_3,pos={520,10},size={35,20},proc=CellHelpParButtonProc,title="?"

        Button button_4,pos={324,10},size={100,20},proc=SaveCellPanelButton,title="Save State"
        Button button_5,pos={324,35},size={100,20},proc=RestoreCellPanelButton,title="Restore State"
        
        Edit/W=(14,60,582,318)/HOST=#
        ModifyTable width(Point)=0
        RenameWindow #,T0

        WAVE/T CellName
        WAVE lambda,Te,err_Te,mu,err_mu

        AppendtoTable/W=# CellName,lambda,Te,err_Te,mu,err_mu
        SetActiveSubwindow ##

        SetDataFolder root:
        return(0)
End


Function SaveCellPanelButton(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        SaveCellParameterTable()
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End

Function RestoreCellPanelButton(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        RestoreCellParameterTable()
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End




Function CellHelpParButtonProc(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        DisplayHelpTopic/Z/K=1 "Fundamental Cell Parameters"
                        if(V_flag !=0)
                                DoAlert 0,"The Cell Parameter Help file could not be found"
                        endif
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End


Function AddCellButtonProc(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        SetDataFolder root:Packages:NIST:Polarization:Cells

                        WAVE/T CellName
                        WAVE lambda,Te,err_Te,mu,err_mu
                        Variable ii= numpnts(CellName)
                        
                        InsertPoints  ii, 1, CellName,lambda,Te,err_Te,mu,err_mu
                        
                        SetDataFolder root:
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End

Function SaveCellParButtonProc(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        Save_HeCell_ParamWaves()
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End

Function RevertCellParButtonProc(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        InitPolarizationGlobals()
                        Make_HeCell_ParamWaves()
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End

// END PROCEDURES for He cell parameters
/////////////////////////////////






// Decay parameters for each cell. Results are stored in a wave note for each cell
//
//      muP=
//      err_muP=
// P0=
//      err_P0=         ? is this needed?
//      T0=
// gamma=
//      err_gamma=
//
// str = "muP=2,err_muP=0,P0=0.6,err_P0=0,T0=asdf,gamma=200,err_gamma=0,"
//
//
// for this panel, the cell parameters are stored as kw strings
// all of the strings start w/ "gDecay_"
//
Proc ShowCellDecayPanel()
        
        // init folders
        // ASK before initializing cell constants
        // open the panel
        DoWindow/F DecayPanel
        if(V_flag == 0)
                InitPolarizationFolders()
                InitDecayGlobals()
                DecayParamPanel()
        endif
        // be sure that the panel is onscreen
        DoIgorMenu "Control","Retrieve Window"
end

Function InitDecayGlobals()

        SetDataFolder root:Packages:NIST:Polarization:Cells
        
        String/G gMuPo = "muPo"
        String/G gPo = "Po"
        String/G gGamma = "gamma"
        String/G gT0 = "today's the day"
        
        
        SetDataFolder root:
        return(0)
End




// makes the panel for the decay parameter and gamma fitting
//
Function DecayParamPanel()

        SetDataFolder root:Packages:NIST:Polarization:Cells
        
        PauseUpdate; Silent 1           // building window...
        NewPanel /W=(200,44,1013,664)/N=DecayPanel/K=1 as "Cell Decay Parameters"
        ModifyPanel cbRGB=(32768,54615,65535)
//      Button button_3,pos={505,16},size={35,20},proc=DecayHelpParButtonProc,title="?"
        PopupMenu popup_0,pos={32,8},size={49,20},title="Cell",proc=DecayPanelPopMenuProc
        PopupMenu popup_0,mode=1,value= #"D_CellNameList()"
        
        Button button_0,pos={560,294},size={70,20},proc=DecayFitButtonProc,title="Do Fit"
        
        GroupBox group_0,pos={560,329},size={230,149},title="FIT RESULTS",fSize=10
        GroupBox group_0,fStyle=1
        SetVariable setvar_0,pos={570,358},size={200,13},title="muPo of 3He"
        SetVariable setvar_0,fStyle=1,limits={0,0,0},barmisc={0,1000}
        SetVariable setvar_0,value= root:Packages:NIST:Polarization:Cells:gMuPo
        SetVariable setvar_1,pos={570,390},size={200,13},title="Po of 3He"
        SetVariable setvar_1,fStyle=1,limits={0,0,0},barmisc={0,1000}
        SetVariable setvar_1,value= root:Packages:NIST:Polarization:Cells:gPo
        SetVariable setvar_2,pos={570,448},size={200,13},title="Gamma (h)",fStyle=1
        SetVariable setvar_2,limits={0,0,0},barmisc={0,1000}
        SetVariable setvar_2,value= root:Packages:NIST:Polarization:Cells:gGamma
        SetVariable setvar_3,pos={570,418},size={200,13},title="T0",fStyle=1
        SetVariable setvar_3,limits={0,0,0},value= root:Packages:NIST:Polarization:Cells:gT0
        

        Button button_1,pos={560,262},size={120,20},proc=CalcRowParamButton,title="Calculate Rows"
        Button button_2,pos={307,8},size={110,20},proc=ClearDecayWavesButton,title="Clear Table"
        Button button_3,pos={560,519},size={110,20},proc=ShowCalcRowButton,title="Show Calc"
        Button button_4,pos={440,8},size={110,20},proc=ClearDecayWavesRowButton,title="Clear Row"
        Button button_5,pos={620,8},size={40,20},proc=DecayHelpParButtonProc,title="?"
        Button button_6,pos={560,574},size={110,20},proc=WindowSnapshotButton,title="Snapshot"
        Button button_7,pos={560,547},size={110,20},proc=ManualEnterDecayButton,title="Manual Entry"
        Button button_8,pos={690,547},size={110,20},proc=SaveDecayPanelButton,title="Save State"
        Button button_9,pos={690,574},size={110,20},proc=RestoreDecayPanelButton,title="Restore State"
        CheckBox check0,mode=0,pos={560,480},title="Overrride T0?",value=0


        // table
        Edit/W=(14,35,794,240)/HOST=# 
        ModifyTable format=1,width=0
        RenameWindow #,T0
        SetActiveSubwindow ##
        
        // graph
        Display/W=(15,250,540,610)/HOST=#  //root:yy vs root:xx
        ModifyGraph frameStyle=2
        ModifyGraph mode=4
        ModifyGraph marker=19
        ModifyGraph rgb=(0,0,0)
        ModifyGraph msize=2

        Legend
//      ModifyGraph log(left)=1
//      ErrorBars yy OFF 
        RenameWindow #,G0
        SetActiveSubwindow ##

        SetDataFolder root:
        return(0)
End

// allows manual entry of Decay values
//
// see DecayFitButtonProc
//
Function ManualEnterDecayButton(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        Variable selRow,err=0
        String fname, t0str, condStr,noteStr,t1Str,cellStr

        t0Str = "31-OCT-2012 19:30:00"
        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        Variable gamma_val,err_gamma,muPo, err_muPo, Po, err_Po, runNum

                        ControlInfo/W=DecayPanel popup_0
                        cellStr = S_Value
                                
//                      SetDataFolder root:Packages:NIST:Polarization:Cells:
                        
                        WAVE decay=$("root:Packages:NIST:Polarization:Cells:Decay_"+cellStr)            //the one that is displayed
//                      WAVE calc=$("root:Packages:NIST:Polarization:Cells:DecayCalc_"+cellStr)         //with the results


                        Prompt Po, "Enter Po: "         
                        Prompt err_Po, "Enter err_Po: "         
                        Prompt muPo, "Enter muPo: "             
                        Prompt err_muPo, "Enter err_muPo: "             
                        Prompt gamma_val, "Enter gamma: "               
                        Prompt err_gamma, "Enter err_gamma: "
                        Prompt t0Str,"Enter the t=0 time DD-MMM-YYYY HH:MM:SS"
//                      Prompt runNum,"Run number for time=0 of decay"  
                        DoPrompt "Enter Cell Decay Parameters", Po, err_Po, muPo, err_muPo, gamma_val, err_gamma, t0Str
                        if (V_Flag)
                                return -1                                                               // User canceled
                        endif
        
        // enter the time as a string now, rather than from a run number                
//                      fname = FindFileFromRunNumber(runNum)
//                      t0str = getFileCreationDate(fname)
                                        
//              for the wave note
                        noteStr = note(decay)
                        noteStr = ReplaceNumberByKey("muP", noteStr, MuPo ,"=", ",", 0)
                        noteStr = ReplaceNumberByKey("P0", noteStr, Po ,"=", ",", 0)
                        noteStr = ReplaceNumberByKey("err_muP", noteStr, err_muPo ,"=", ",", 0)
                        noteStr = ReplaceNumberByKey("err_P0", noteStr, err_Po ,"=", ",", 0)
                        noteStr = ReplaceNumberByKey("gamma", noteStr, gamma_val ,"=", ",", 0)
                        noteStr = ReplaceNumberByKey("err_gamma", noteStr, err_gamma ,"=", ",", 0)
                        noteStr = ReplaceStringByKey("T0", noteStr, t0Str  ,"=", ",", 0)
                        // replace the string
                        Note/K decay
                        Note decay, noteStr

                        // for the panel display
                        SVAR gGamma  = root:Packages:NIST:Polarization:Cells:gGamma
                        SVAR gMuPo = root:Packages:NIST:Polarization:Cells:gMuPo
                        SVAR gPo  = root:Packages:NIST:Polarization:Cells:gPo           
                        SVAR gT0 = root:Packages:NIST:Polarization:Cells:gT0
                        
                        gT0 = t0Str             //for display
                        sprintf gMuPo, "%g +/- %g",muPo, err_muPo
                        sprintf gPo, "%g +/- %g",Po,err_Po
                        sprintf gGamma, "%g +/- %g",gamma_val,err_gamma

                        
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End


Function DecayPanelPopMenuProc(pa) : PopupMenuControl
        STRUCT WMPopupAction &pa

        switch( pa.eventCode )
                case 2: // mouse up
                        Variable popNum = pa.popNum
                        String popStr = pa.popStr
                        
                        SetDataFolder root:Packages:NIST:Polarization:Cells

                        // based on the selected string, display the right set of inputs
//                      Print "now I need to display the right set of waves (2D text?) for ",popStr

                        // for the given cell name, if the wave(s) exist, declare them
                        if(exists("Decay_"+popStr) == 1)
                                WAVE decay = $("Decay_"+popStr)
                        else
                                // if not, make it, and the space for the results of the calculation
                                MakeDecayResultWaves(popStr)
                                WAVE decay = $("root:Packages:NIST:Polarization:Cells:Decay_"+popStr)
                        endif                   
                        // append matrix, clearing the old one first
                        SetDataFolder root:Packages:NIST:Polarization:Cells

                        KillWindow DecayPanel#T0
                        Edit/W=(14,35,794,240)/HOST=DecayPanel
                        RenameWindow #,T0
                        AppendtoTable/W=DecayPanel#T0 decay.ld                  //show the labels
                        ModifyTable width(Point)=0
                        ModifyTable width(decay.l)=20
                        
                        SetActiveSubwindow ##
        
                        SetDataFolder root:
                        
                        //
                        // now show the fit results, if any, from the wave note
                        //
                        SVAR gMuPo = root:Packages:NIST:Polarization:Cells:gMuPo
                        SVAR gPo  = root:Packages:NIST:Polarization:Cells:gPo
                        SVAR gGamma  = root:Packages:NIST:Polarization:Cells:gGamma
                        SVAR gT0  = root:Packages:NIST:Polarization:Cells:gT0
                        String nStr=note(decay)
                        

                        // for the panel display
                        sprintf gMuPo, "%g +/- %g",NumberByKey("muP", nStr, "=",","),NumberByKey("err_muP", nStr, "=",",")
                        sprintf gPo, "%g +/- %g",NumberByKey("P0", nStr, "=",","),NumberByKey("err_P0", nStr, "=",",")
                        sprintf gGamma, "%g +/- %g",NumberByKey("gamma", nStr, "=",","),NumberByKey("err_gamma", nStr, "=",",")
                        gT0 = StringByKey("T0", nStr, "=",",")
                
                        
                        // clear the graph - force the user to update it manually
                        // clear old data, and plot the new
                        //
                        SetDataFolder root:Packages:NIST:Polarization:Cells:

                        CheckDisplayed/W=DecayPanel#G0 tmp_muP,tmp_muP2,fit_tmp_muP
                        // if both present, bit 0 + bit 1 = 3
                        if(V_flag & 2^0)                        //check bit 0
                                RemoveFromGraph/W=DecayPanel#G0 tmp_muP
                        endif
                        if(V_flag & 2^1)
                                RemoveFromGraph/W=DecayPanel#G0 tmp_muP2
                        endif
                        if(V_flag & 2^2)
                                RemoveFromGraph/W=DecayPanel#G0 fit_tmp_muP
                        endif
                        
                        // kill the text box (name is hard-wired)
                        TextBox/W=DecayPanel#G0/K/N=CF_tmp_muP
                        
                        setDataFolder root:
                        
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End

Function MakeDecayResultWaves(popStr)
        String popStr

        SetDataFolder root:Packages:NIST:Polarization:Cells

        Make/O/D/N=(1,9) $("Decay_"+popStr)
        WAVE decay = $("Decay_"+popStr)
        // set the column labels
        SetDimLabel 1,0,'Trans_He_In?',decay
        SetDimLabel 1,1,'Trans_He_Out?',decay
        SetDimLabel 1,2,'Blocked?',decay
        SetDimLabel 1,3,mu_star,decay
        SetDimLabel 1,4,Effective_Pol,decay
        SetDimLabel 1,5,Atomic_Pol,decay
        SetDimLabel 1,6,T_Major,decay
        SetDimLabel 1,7,'Include?',decay                        //for a mask wave, non-zero is used in the fit
        SetDimLabel 1,8,elapsed_hr,decay
        decay[0][7] = 1                 //default to include the point
        
        // generate the dummy wave note now, change as needed
        Note decay, "muP=0,err_muP=0,P0=0,err_P0=0,T0=undefined,gamma=0,err_gamma=0,"
        
        // to hold the results of the calculation
        Make/O/D/N=(1,14) $("DecayCalc_"+popStr)
        WAVE decayCalc = $("DecayCalc_"+popStr)
        SetDimLabel 1,0,CR_Trans_He_In,decayCalc
        SetDimLabel 1,1,err_CR_Trans_He_In,decayCalc
        SetDimLabel 1,2,CR_Trans_He_Out,decayCalc
        SetDimLabel 1,3,err_CR_Trans_He_Out,decayCalc
        SetDimLabel 1,4,CR_Blocked,decayCalc
        SetDimLabel 1,5,err_CR_Blocked,decayCalc
        SetDimLabel 1,6,muPo,decayCalc
        SetDimLabel 1,7,err_muPo,decayCalc
        SetDimLabel 1,8,Po,decayCalc
        SetDimLabel 1,9,err_Po,decayCalc
        SetDimLabel 1,10,Tmaj,decayCalc
        SetDimLabel 1,11,err_Tmaj,decayCalc
        SetDimLabel 1,12,gamm,decayCalc
        SetDimLabel 1,13,err_gamm,decayCalc     

        SetDataFolder root:

        return(0)
End


// since the "Decay_" table can be edited directly to increase the number of rows, it is tough
// to increase the number of rows in the "DecayCalc_" wave and keep them in sync.
//
// --so make sure that the sizes match, and do them all
//
Function CalcRowParamButton(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        Variable selRow,err=0
        String fname, t0str, cellStr,noteStr,t1Str

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        Variable cr1,cr2,cr3,err_cr1,err_cr2,err_cr3
                        Variable muPo,err_muPo,Po,err_Po,Pcell,err_Pcell,Tmaj,err_Tmaj
                        //Variable Te,err_Te,mu,err_mu
                                
                        ControlInfo/W=DecayPanel popup_0
                        cellStr = S_Value
                        WAVE w=$("root:Packages:NIST:Polarization:Cells:Decay_"+cellStr)                //the one that is displayed
                        WAVE calc=$("root:Packages:NIST:Polarization:Cells:DecayCalc_"+cellStr)         // behind the scenes
                        
                        Variable numRows,ncalc,diff
                        numRows = DimSize(w,0)          //rows in the displayed table
                        ncalc = DimSize(calc,0)
                        
                        // add rows to the DecayCalc_ matrix as needed
                        if(numRows != ncalc)
                                if(ncalc > numRows)
                                        DoAlert 0,"The DecayCalc_ is larger than displayed. Seek help."
                                        err = 1
                                        return(err)
                                else
                                        diff = numRows - ncalc
                                        InsertPoints/M=0 ncalc, diff, calc
                                endif
                        endif
                        
                        
//                      GetSelection table, DecayPanel#T0, 1
//                      selRow = V_startRow

                        Variable sum_muP, err_avg_muP, sum_Po, err_avg_Po, avg_muP, avg_Po, overrideT0
                        sum_muP = 0
                        sum_Po = 0
                        err_avg_muP = 0
                        err_avg_Po = 0
                        
                        ControlInfo/W=DecayPanel check0
                        overrideT0 = V_Value
                        
                        for(selRow=0;selRow<numRows;selRow+=1)
                                Print "calculate the row ",selRow

                                if(selRow == 0 && !overrideT0)
                                        //find T0
                                        fname = FindFileFromRunNumber(w[0][%'Trans_He_In?'])
                                        t0str = getFileCreationDate(fname)
                                        SVAR gT0 = root:Packages:NIST:Polarization:Cells:gT0
                                        gT0 = t0Str             //for display
                                        noteStr = note(w)
                                        noteStr = ReplaceStringByKey("T0", noteStr, gT0  ,"=", ",", 0)
                                        Note/K w
                                        Note w, noteStr
                                        Print t0str
                                else
                                        // manually entered on the panel to override the 
                                        SVAR gT0 = root:Packages:NIST:Polarization:Cells:gT0
                                        t0Str = gT0
                                        noteStr = note(w)
                                        noteStr = ReplaceStringByKey("T0", noteStr, gT0  ,"=", ",", 0)
                                        Note/K w
                                        Note w, noteStr
                                        Print t0str
                                endif
                                
                                // parse the rows, report errors (there, not here), exit if any found
                                err = ParseDecayRow(w,selRow)
                                if(err)
                                        return 0
                                endif
                                
                                // do the calculations:
                                // 1 for each file, return the count rate and err_CR (normalize to atten or not)
        
                                cr1 = TotalCR_FromRun(w[selRow][%'Trans_He_In?'],err_cr1,0)
                                cr2 = TotalCR_FromRun(w[selRow][%'Trans_He_Out?'],err_cr2,0)
//                              cr3 = TotalCR_FromRun(w[selRow][%'Blocked?'],err_cr3,1)                 //blocked beam is NOT normalized to zero attenuators
//                              Print "************The Blocked CR is *NOT* rescaled to zero attenuators -- CalcRowParamButton"
                                cr3 = TotalCR_FromRun(w[selRow][%'Blocked?'],err_cr3,0)                 //blocked beam is normalized to zero attenuators
                                Print "************The Blocked CR *is* rescaled to zero attenuators -- CalcRowParamButton "


                                calc[selRow][%CR_Trans_He_In] = cr1
                                calc[selRow][%CR_Trans_He_Out] = cr2
                                calc[selRow][%CR_Blocked] = cr3
                                calc[selRow][%err_cr_Trans_He_In] = err_cr1
                                calc[selRow][%err_cr_Trans_He_Out] = err_cr2
                                calc[selRow][%err_cr_Blocked] = err_cr3
        
        
                                // 2 find the mu and Te values for cellStr
                                SVAR gCellKW = $("root:Packages:NIST:Polarization:Cells:gCell_"+cellStr)

        //                      
                                // 3 Calc muPo and error
                                muPo = Calc_muPo(calc,gCellKW,selRow,err_muPo)
                                calc[selRow][%muPo] = muPo
                                calc[selRow][%err_muPo] = err_muPo
                                w[selRow][%mu_star] = muPo
                                
                                // 3.5 calc Polarization of cell (no value or error stored in calc wave?)
                                PCell = Calc_PCell(muPo,err_muPo,err_PCell)
                                w[selRow][%Effective_Pol] = PCell
        
                                // 4 calc Po and error
                                Po = Calc_Po(gCellKW,muPo,err_muPo,err_Po)
                                calc[selRow][%Po] = Po
                                calc[selRow][%err_Po] = err_Po
                                w[selRow][%Atomic_Pol] = Po             //for display
                                
                                // 5 calc Tmaj and error
                                Tmaj = Calc_Tmaj(gCellKW,Po,err_Po,err_Tmaj)
                                calc[selRow][%Tmaj] = Tmaj
                                calc[selRow][%err_Tmaj] = err_Tmaj
                                w[selRow][%T_major] = Tmaj
                                
                                // elapsed hours
                                fname = FindFileFromRunNumber(w[selRow][%'Trans_He_In?'])
                                t1str = getFileCreationDate(fname)
                                w[selRow][%elapsed_hr] = ElapsedHours(t0Str,t1Str)
                                
                                // running average of muP and Po
                                sum_muP += muPo
                                sum_Po += Po
                                err_avg_muP += err_muPo^2
                                err_avg_Po += err_Po^2
                                
                        endfor          //loop over rows


////// 26 APR 12 -- why was I getting a running average of these values??               not sure, so I commented them out...
//                              they aren't returned or used anywhere...
//                      // now get a running average of muP, Po, and the errors
//                      avg_muP = sum_muP/numRows
//                      avg_Po = sum_Po/numRows
//                      err_avg_muP = sqrt(err_avg_muP) / numRows
//                      err_avg_Po = sqrt(err_avg_Po) / numRows
//      
//
//                      Printf "Average muP = %g +/- %g (%g%)\r",avg_muP,err_avg_muP,err_avg_muP/avg_muP*100
//                      Printf "Average Po = %g +/- %g (%g%)\r",avg_Po,err_avg_Po,err_avg_Po/avg_Po*100
//                      
//              E  26 APR 12
                
//                      str = "muP=2,err_muP=0,P0=0.6,err_P0=0,T0=asdf,gamma=200,err_gamma=0,"

                        // Don't put the average values into the wave note, but rather the results of the fit
//                      noteStr = note(w)
//                      noteStr = ReplaceNumberByKey("muP", noteStr, avg_muP ,"=", ",", 0)
//                      noteStr = ReplaceNumberByKey("P0", noteStr, avg_Po ,"=", ",", 0)
//                      noteStr = ReplaceNumberByKey("err_muP", noteStr, err_avg_muP ,"=", ",", 0)
//                      noteStr = ReplaceNumberByKey("err_P0", noteStr, err_avg_Po ,"=", ",", 0)
//                      
//                      // replace the string
//                      Note/K w
//                      Note w, noteStr
                                        

                        
                        //update the global values for display (not these, but after the fit)
//                      Print " -- need to add the error to the display on the panel    "
//                      NVAR gMuPo = root:Packages:NIST:Polarization:Cells:gMuPo
//                      NVAR gPo  = root:Packages:NIST:Polarization:Cells:gPo
//                      gMuPo = avg_muP
//                      gPo = avg_Po
                        
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End


// calculate Tmaj and its error
Function Calc_Tmaj(cellStr,Po,err_Po,err_Tmaj)
        String cellStr
        Variable Po,err_Po,&err_Tmaj
        
        Variable Tmaj,arg
        Variable Te,err_Te,mu,err_mu
// cell constants       
        Te = NumberByKey("Te", cellStr, "=", ",", 0)
        err_Te = NumberByKey("err_Te", cellStr, "=", ",", 0)
        mu = NumberByKey("mu", cellStr, "=", ",", 0)
        err_mu = NumberByKey("err_mu", cellStr, "=", ",", 0)
        
        Tmaj = Te*exp(-mu*(1-Po))
        
        //the error
        err_Tmaj = (Tmaj/Te)^2*err_Te^2 + (Tmaj*(1-Po))^2*err_mu^2 + (Tmaj*mu)^2*err_Po^2
        err_Tmaj = sqrt(err_Tmaj)
        
        Printf "Tmaj = %g +/- %g (%g%)\r",Tmaj,err_Tmaj,err_Tmaj/Tmaj*100

        
        return(Tmaj)
End


// calculate Tmin and its error
Function Calc_Tmin(cellStr,Po,err_Po,err_Tmin)
        String cellStr
        Variable Po,err_Po,&err_Tmin
        
        Variable Tmin,arg
        Variable Te,err_Te,mu,err_mu
// cell constants       
        Te = NumberByKey("Te", cellStr, "=", ",", 0)
        err_Te = NumberByKey("err_Te", cellStr, "=", ",", 0)
        mu = NumberByKey("mu", cellStr, "=", ",", 0)
        err_mu = NumberByKey("err_mu", cellStr, "=", ",", 0)
        
        Tmin = Te*exp(-mu*(1+Po))
        
        //the error
        err_Tmin = (Tmin/Te)^2*err_Te^2 + (Tmin*(1+Po))^2*err_mu^2 + (Tmin*mu)^2*err_Po^2
        err_Tmin = sqrt(err_Tmin)
        
        Printf "Tmin = %g +/- %g (%g%)\r",Tmin,err_Tmin,err_Tmin/Tmin*100

        
        return(Tmin)
End



// calculate PCell and its error
//
// 
Function Calc_PCell(muPo,err_muPo,err_PCell)
        Variable muPo,err_muPo,&err_PCell
        
        Variable PCell,arg

        PCell = tanh(muPo)
        
        // error (single term, sqrt already done)
        err_Pcell = (1 - (tanh(muPo))^2) * err_muPo
        
        Printf "Pcell = %g +/- %g (%g%)\r",Pcell,err_Pcell,err_Pcell/PCell*100

        return(PCell)
End

// calculate Po and its error
Function Calc_Po(cellStr,muPo,err_muPo,err_Po)
        String cellStr
        Variable muPo,err_muPo,&err_Po
        
        Variable Po,tmp
        Variable mu,err_mu
// cell constants       
        mu = NumberByKey("mu", cellStr, "=", ",", 0)
        err_mu = NumberByKey("err_mu", cellStr, "=", ",", 0)
        
        Po = muPo/mu
        
        tmp = (err_muPo/muPo)^2 + (err_mu/mu)^2
        err_Po = Po * sqrt(tmp)
//      tmp = 1/mu^2*err_muPo^2 + muPo^2/mu^4*err_mu^2
//      err_Po = sqrt(tmp)
        
        Printf "Po = %g +/- %g (%g%)\r",Po,err_Po,err_Po/Po*100
        return(Po)
End

// calculate muPo and its error
Function Calc_muPo(calc,cellStr,selRow,err_muPo)
        Wave calc
        String cellStr
        Variable selRow,&err_muPo
        
        Variable muPo,arg
        Variable Te,err_Te,mu,err_mu
// cell constants       
        Te = NumberByKey("Te", cellStr, "=", ",", 0)
        err_Te = NumberByKey("err_Te", cellStr, "=", ",", 0)
        mu = NumberByKey("mu", cellStr, "=", ",", 0)
        err_mu = NumberByKey("err_mu", cellStr, "=", ",", 0)
        
        Variable cr1,cr2,cr3,err_cr1,err_cr2,err_cr3
        // cr1 is He in, 2 is He out, 3 is blocked
        cr1      =      calc[selRow][%CR_Trans_He_In]
        cr2 =   calc[selRow][%CR_Trans_He_Out]
        cr3 =   calc[selRow][%CR_Blocked]
        err_cr1 =       calc[selRow][%err_cr_Trans_He_In]
        err_cr2 =       calc[selRow][%err_cr_Trans_He_Out]
        err_cr3 =       calc[selRow][%err_cr_Blocked]
        
        muPo = acosh( (cr1 - cr3)/(cr2 - cr3) * (1/(Te*exp(-mu))) )
        
        Variable arg_err, tmp1, tmp2
        // the error is a big mess to calculate, since it's messy argument inside acosh
        arg = (cr1 - cr3)/(cr2 - cr3) * (1/(Te*exp(-mu)))
        tmp2 =  (1/sqrt(arg+1)/sqrt(arg-1))^2                                   // derivative of acosh(arg) (squared)
        
        // calculate the error of the argument first, then the error of acosh(arg)
        // there are 5 partial derivatives
        arg_err = tmp2 * ( arg/(cr1 - cr3) * err_cr1 )^2                //CR in
        arg_err += tmp2 * ( arg/(cr2 - cr3) * err_cr2 )^2       //CR out
        arg_err += tmp2 * ((-arg/(cr1 - cr3) +  arg/(cr2 - cr3) )* err_cr3 )^2//CR bkg 
        arg_err += tmp2 * ( -arg/Te * err_Te )^2                                        //Te
        arg_err += tmp2 * ( arg * err_mu )^2                                            //mu  (probably the dominant relative error)
        
        err_muPo = sqrt(arg_err)
        
        
        return(muPo)
End


Function testCR(num)
        Variable num
        Variable err_cr
        
        Variable noNorm=0
        Variable cr = TotalCR_FromRun(num,err_cr,noNorm)
        printf "CR = %g +/- %g (%g%)\r",cr,err_cr,err_cr/cr*100 
        return(0)
End

// calculate the total detector CR and its error.
//
// the result is automatically normalized to 10^8 monitor counts, and to zero attenuators
//
// if noNorm = 1, then the normalization to attenuators is not done
//
Function TotalCR_FromRun(num,err_cr,noNorm)
        Variable num,&err_cr,noNorm

        String fname="",instr="",tmpStr=""
        Variable cr,cts,err_cts,ctTime,monCts,attenNo,lambda,attenTrans,atten_err
        
        fname = FindFileFromRunNumber(num)
        cts = getDetCount(fname)
        err_cts = sqrt(cts)
        
        ctTime = getCountTime(fname)
        monCts = getMonitorCount(fname)
        attenNo = getAttenNumber(fname)
        instr = getAcctName(fname)              //this is 11 characters
        lambda = getWavelength(fname)
        attenTrans = AttenuationFactor(instr,lambda,AttenNo,atten_err)
        
        if(noNorm==1)                   //don't normalize to attenuation
                attenTrans=1
                atten_err=0
        endif
        cr = cts/ctTime*1e8/monCts/attenTrans
        err_cr = cr * sqrt(err_cts^2/cts^2 + atten_err^2/attenTrans^2)
        
        printf "CR = %g +/- %g (%g%)\r",cr,err_cr,err_cr/cr*100 

                
        return(cr)
end


// input is VAX date and time string, t1 later than t0
//
Function ElapsedHours(t0Str,t1Str)
        String t0Str,t1Str
        
        Variable t0,t1,elapsed
        
        t0 = ConvertVAXDateTime2Secs(t0Str)             //seconds
        t1 = ConvertVAXDateTime2Secs(t1Str)
        
        elapsed = t1-t0
        elapsed /= 3600                 //convert to hours
        
        return(elapsed)
End

// bring up a table with the calculation results
Function ShowCalcRowButton(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        ControlInfo/W=DecayPanel popup_0
                        String cellStr = S_Value
                        WAVE calc=$("root:Packages:NIST:Polarization:Cells:DecayCalc_"+cellStr)         //the one that is displayed
                        edit calc.ld
                                                
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End


Function DecayFitButtonProc(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        String cellStr=""
        Variable num,plot_P
        
        plot_P = 1              //plot_Pol as Y, or muP if this == 0

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here

                        ControlInfo/W=DecayPanel popup_0
                        cellStr = S_Value
                        
                        SetDataFolder root:Packages:NIST:Polarization:Cells:
                        
                        WAVE decay=$("Decay_"+cellStr)          //the one that is displayed
                        WAVE calc=$("DecayCalc_"+cellStr)               //the one that is displayed
                        
//                      make temp copies for the fit and plot, extra for mask
                        num = DimSize(calc,0)
                        Make/O/D/N=(num)                tmp_Mask,tmp_hr,tmp_Y,tmp_err_Y,tmp_Y2
                        
                        tmp_Mask = decay[p][%'Include?']
                        tmp_hr = decay[p][%elapsed_hr]
                        
                        if(plot_P == 1)
                                tmp_Y = calc[p][%Po]
                                tmp_Y2 = tmp_Y
                                tmp_err_Y = calc[p][%err_Po]                    
                        else            //plot muP as the y-axis
                                tmp_Y = calc[p][%muPo]
                                tmp_Y2 = tmp_Y
                                tmp_err_Y = calc[p][%err_muPo]
                        endif

                        tmp_Y2 = (tmp_Mask == 1) ? NaN : tmp_Y2                 //only excluded points will plot
                        



                        // clear old data, and plot the new
                        //
                        CheckDisplayed/W=DecayPanel#G0 tmp_Y,tmp_Y2,fit_tmp_Y
                        // if both present, bit 0 + bit 1 = 3
                        if(V_flag & 2^0)                        //check bit 0
                                RemoveFromGraph/W=DecayPanel#G0 tmp_Y
                        endif
                        if(V_flag & 2^1)
                                RemoveFromGraph/W=DecayPanel#G0 tmp_Y2
                        endif
                        if(V_flag & 2^2)
                                RemoveFromGraph/W=DecayPanel#G0 fit_tmp_Y
                        endif
                        
                        AppendToGraph/W=DecayPanel#G0 tmp_Y vs tmp_hr
                        AppendToGraph/W=DecayPanel#G0 tmp_Y2 vs tmp_hr

                        ModifyGraph/W=DecayPanel#G0 log(left)=1
                        ModifyGraph/W=DecayPanel#G0 frameStyle=2
                        ModifyGraph/W=DecayPanel#G0 mode=3
                        ModifyGraph/W=DecayPanel#G0 marker=19
                        ModifyGraph/W=DecayPanel#G0 rgb(tmp_Y)=(1,16019,65535),rgb(tmp_Y2)=(65535,0,0)
                        ModifyGraph/W=DecayPanel#G0 msize=3
                        ErrorBars/W=DecayPanel#G0 tmp_Y,Y wave=(tmp_err_Y,tmp_err_Y)

                        if(plot_P == 1)
                                Label/W=DecayPanel#G0 left "Atomic Polarization, P"
                        else
                                Label/W=DecayPanel#G0 left "mu*P"
                        endif                   
                        Label/W=DecayPanel#G0 bottom "time (h)"
                        
// do the fit
//       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
// -- use the /K={0} flag to set the constant to zero

                        SetActiveSubwindow DecayPanel#G0                        //to get the automatic fit to show up on the graph

                        Make/O/D/N=3 fitCoef={0,5,0.05}
                        CurveFit/H="100"/M=2/W=0/TBOX=(0x310)/K={0} exp_XOffset, kwCWave=fitCoef, tmp_Y /X=tmp_hr /D /I=1 /W=tmp_err_Y /M=tmp_Mask
// gives nice error on gamma, but it's wrong since it doesn't use the errors on muP
//                      CurveFit/H="100"/M=2/W=0/TBOX=(0x310)/K={0} exp_XOffset, kwCWave=fitCoef, tmp_Y /X=tmp_hr /D /M=tmp_Mask


//                      Make/O/D/N=3 fitCoef={0,5,0.05}
//                      CurveFit/H="100"/M=2/W=0/TBOX=(0x310) exp, kwCWave=fitCoef, tmp_Y /X=tmp_hr /D /I=1 /W=tmp_err_Y /M=tmp_Mask
                        

                        SetActiveSubwindow ##
                        
                        
// then report and save the results
//                      the exp function => y = y0 + A*exp(-Bx)
//                      W_coef[0] = y0 should be close to zero (or fixed at zero)
//                      W_coef[1] = A should be close to the initial muP value
//                      W_coef[2] = B is 1/Gamma
//                      WAVE W_coef=W_coef
                        WAVE W_sigma=W_sigma
                        Variable gamma_val,err_gamma,muPo, err_muPo, Po, err_Po
                        String noteStr=""
        
                        SVAR gCellKW = $("root:Packages:NIST:Polarization:Cells:gCell_"+cellStr)        
                        SVAR gGamma  = root:Packages:NIST:Polarization:Cells:gGamma
                        SVAR gMuPo = root:Packages:NIST:Polarization:Cells:gMuPo
                        SVAR gPo  = root:Packages:NIST:Polarization:Cells:gPo

                        Variable mu,err_mu

                        if(plot_P == 1)
                                Po = fitCoef[1]
                                err_Po = W_sigma[1]
                        // calc muPo inline here, since the Calc_muP function uses a different method
                        // cell constants       
                                mu = NumberByKey("mu", gCellKW, "=", ",", 0)
                                err_mu = NumberByKey("err_mu", gCellKW, "=", ",", 0)
                                
                                muPo = Po*mu
                                err_muPo = muPo*sqrt( (err_Po/Po)^2 + (err_mu/mu)^2 )
                        else
                                muPo = fitCoef[1]
                                err_muPo = W_sigma[1]
                                
                                Po = Calc_Po(gCellKW,muPo,err_muPo,err_Po)
                        endif
                        


                        // if exp_XOffset used
                        gamma_val = fitCoef[2]
                        err_Gamma = W_sigma[2]

                        // calculating the error using exp is the inverse of coef[2]:
//                      gamma_val  = 1/fitCoef[2]
//                      err_gamma = W_sigma[2]/(fitCoef[2])^2
                
                        
//              for the wave note
                        noteStr = note(decay)
                        noteStr = ReplaceNumberByKey("muP", noteStr, MuPo ,"=", ",", 0)
                        noteStr = ReplaceNumberByKey("P0", noteStr, Po ,"=", ",", 0)
                        noteStr = ReplaceNumberByKey("err_muP", noteStr, err_muPo ,"=", ",", 0)
                        noteStr = ReplaceNumberByKey("err_P0", noteStr, err_Po ,"=", ",", 0)
                        noteStr = ReplaceNumberByKey("gamma", noteStr, gamma_val ,"=", ",", 0)
                        noteStr = ReplaceNumberByKey("err_gamma", noteStr, err_gamma ,"=", ",", 0)

                        // replace the string
                        Note/K decay
                        Note decay, noteStr
                        
                        
                        // for the panel display
                        sprintf gMuPo, "%g +/- %g",muPo,err_muPo
                        sprintf gPo, "%g +/- %g",Po,err_Po
                        sprintf gGamma, "%g +/- %g",gamma_val,err_gamma

                        
                        
                        SetDataFolder root:
                        
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End


// clear just the row
//
Function ClearDecayWavesRowButton(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        String popStr=""
        Variable selRow
        
        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        DoAlert 1,"Clear the selected row?"
                        if(V_flag !=1)
                                return(0)
                        endif
                        
                        SetDataFolder root:Packages:NIST:Polarization:Cells

                        ControlInfo/W=DecayPanel popup_0
                        popStr = S_Value
                        
                        Wave decay = $("Decay_"+popStr)
                        Wave calc = $("DecayCalc_"+popStr)

                        // Delete just those points
                                                
                        GetSelection table, DecayPanel#T0, 1
                        selRow = V_startRow
                        DeletePoints selRow,1,decay,calc                        
                        
                        // clear the graph and the results                      
                        SVAR gMuPo = root:Packages:NIST:Polarization:Cells:gMuPo
                        SVAR gPo  = root:Packages:NIST:Polarization:Cells:gPo
                        SVAR gGamma  = root:Packages:NIST:Polarization:Cells:gGamma
                        SVAR gT0  = root:Packages:NIST:Polarization:Cells:gT0
                        gMuPo = "0"
                        gPo = "0"
                        gGamma = "0"
                        gT0 = "recalculate"
                        
                        SetDataFolder root:
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End



// for this, do I want to clear everything, or just a selected row??
//
//
Function ClearDecayWavesButton(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        String popStr=""
        
        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        DoAlert 1,"Clear all of the decay waves for the selected cell?"
                        if(V_flag !=1)
                                return(0)
                        endif
                        
                        SetDataFolder root:Packages:NIST:Polarization:Cells

                        ControlInfo/W=DecayPanel popup_0
                        popStr = S_Value
                        
                        Wave decay = $("Decay_"+popStr)
                        Wave calc = $("DecayCalc_"+popStr)
                        
//                      re-initialize the decay waves, so it appears as a blank, initialized table

                        MakeDecayResultWaves(popStr)
                        decay = 0
                        calc = 0
        
                        // clear the graph and the results?     
                        
                        
                                        
                        SVAR gMuPo = root:Packages:NIST:Polarization:Cells:gMuPo
                        SVAR gPo  = root:Packages:NIST:Polarization:Cells:gPo
                        SVAR gGamma  = root:Packages:NIST:Polarization:Cells:gGamma
                        SVAR gT0  = root:Packages:NIST:Polarization:Cells:gT0
                        gMuPo = "0"
                        gPo = "0"
                        gGamma = "0"
                        gT0 = "recalculate"
                        
                        
                        SetDataFolder root:
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End


Function DecayHelpParButtonProc(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        DisplayHelpTopic/Z/K=1 "Cell Decay Constant Panel"
                        if(V_flag !=0)
                                DoAlert 0,"The Cell Decay Help file could not be found"
                        endif
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End

// E=-5 is a PNG, =8 is PDF
// there are other options to do EPS, embed fonts, etc.
//
Function WindowSnapshotButton(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        SavePICT /E=-5/SNAP=1
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End

Function SaveDecayPanelButton(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        SaveCellDecayTable()
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End

Function RestoreDecayPanelButton(ba) : ButtonControl
        STRUCT WMButtonAction &ba

        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        RestoreCellDecayTable()
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End

// null condition is not right. if the loop fails, then the 
// retStr will be ";;;;", not zero length. What's the proper test?
// Does it matter? the list of default gCell_sss should already be there.
//
Function/S D_CellNameList()

        String retStr="",listStr,item
        Variable num,ii
        
        SetDataFolder root:Packages:NIST:Polarization:Cells

        // get a list of the cell strings
        listStr=StringList("gCell_*",";")
        num=ItemsInList(listStr,";")
//      print listStr
        
        // parse the strings to fill the table
        for(ii=0;ii<num;ii+=1)
                item = StringFromList(ii, listStr,";")
                SVAR gStr = $item
                retStr += StringByKey("cell", gStr, "=", ",", 0) + ";"
        endfor
        
        if(strlen(retStr) == 0)
                retStr = "no cells defined;"
        endif
        
        SetDataFolder root:             
        return(retStr)
End


// parse the row to be sure that:
//
// - files are valid numbers
// - files are all at same SDD
// - files are all with same attenuation (just print a warning to cmd)
// - due to ICE FP values, I need to do a fuzzy comparison
//
//
Function ParseDecayRow(w,selRow)
        Wave w
        Variable selRow
        
        Variable err=0, atten1,atten2,atten3,sdd1,sdd2,sdd3,tol
        String fname=""
        tol = 0.01              //SDDs within 1%
        
        // are all file numbers valid?
        fname = FindFileFromRunNumber(w[selRow][%'Trans_He_In?'])
        if(cmpstr(fname,"")==0)
                DoAlert 0,"Trans_He_In run "+num2str(w[selRow][%'Trans_He_In?'])+" is not a valid run number"
                err = 1
        else
                atten1 = getAttenNumber(fname)
                sdd1 = getSDD(fname)
        endif
        
        fname = FindFileFromRunNumber(w[selRow][%'Trans_He_Out?'])
        if(cmpstr(fname,"")==0)
                DoAlert 0,"Trans_He_Out run "+num2str(w[selRow][%'Trans_He_Out?'])+" is not a valid run number"
                err = 1
        else
                atten2 = getAttenNumber(fname)
                sdd2 = getSDD(fname)
        endif
        
        fname = FindFileFromRunNumber(w[selRow][%'Blocked?'])
        if(cmpstr(fname,"")==0)
                DoAlert 0,"Blocked run "+num2str(w[selRow][%'Blocked?'])+" is not a valid run number"
                err = 1
        else
                atten3 = getAttenNumber(fname)
                sdd3 = getSDD(fname)
        endif
        
        
        if( (abs(sdd1 - sdd2) > tol) || (abs(sdd2 - sdd3) > tol) || (abs(sdd1 - sdd3) > tol) )
                DoAlert 0,"Files in row "+num2str(selRow)+" are not all at the same detector distance"
                err = 1
        endif
        
        if( (atten1 != atten2) || (atten2 != atten3) || (atten1 != atten3) )
                DoAlert 0,"Files in row "+num2str(selRow)+" are not all collected with the same attenuation. Just so you know."
                err = 0
        endif
        
        return(err)
end


////////////////////////////////////////////


//
// a simple little panel to calculate the flipping ratio.
// 3 input files, calculates the flipping ratio, then simply reports the result
//

Proc ShowFlippingRatioPanel()
        
        // init folders
        // ASK before initializing cell constants
        // open the panel
        DoWindow/F FlipRatio
        if(V_flag == 0)
                FlippingRatioPanel()
        endif

end

Proc FlippingRatioPanel()
        PauseUpdate; Silent 1           // building window...
        NewPanel /W=(455,44,805,245)/N=FlipRatio/K=1 as "Flipping Ratio"
        ModifyPanel cbRGB=(65535,49157,16385)
//      ShowTools/A
        SetDrawLayer UserBack
        GroupBox group0,pos={12,9},size={307,123},title="Flipping Ratio"
        SetVariable setvar0,pos={23,35},size={150,15},title="UU or DD File"
        SetVariable setvar0,limits={-inf,inf,0},value= _NUM:0
        SetVariable setvar1,pos={23,58},size={150,15},title="UD or DU File"
        SetVariable setvar1,limits={-inf,inf,0},value= _NUM:0
        SetVariable setvar2,pos={23,82},size={150,15},title="Blocked beam"
        SetVariable setvar2,limits={-inf,inf,0},value= _NUM:0
        SetVariable setvar3,pos={23,104},size={240,16},title="Flipping Ratio",fSize=12
        SetVariable setvar3,fStyle=1,limits={-inf,inf,0},value= _STR:"enter the run numbers"
        Button button0,pos={214,55},size={90,20},proc=CalcFlippingRatioButtonProc,title="Calculate"
EndMacro



Function CalcFlippingRatioButtonProc(ba) : ButtonControl
        STRUCT WMButtonAction &ba


        Variable num0,num1,num2,cr0,cr1,cr2,err_cr0,err_cr1,err_cr2
        Variable tmp0,tmp1,tmp2,flip,flip_err
        String str=""
        
        switch( ba.eventCode )
                case 2: // mouse up
                        // click code here
                        
                        ControlInfo setvar0
                        num0 = V_Value
                        ControlInfo setvar1
                        num1 = V_Value
                        ControlInfo setvar2
                        num2 = V_Value
                        
                        cr0 = TotalCR_FromRun(num0,err_cr0,0)           //last zero means yes, normalize everything to zero atten
                        cr1 = TotalCR_FromRun(num1,err_cr1,0)
                        cr2 = TotalCR_FromRun(num2,err_cr2,0)           // this one is the blocked beam
                        
                        
                        flip = (cr0-cr2)/(cr1-cr2)
                        tmp0 = 1/(cr1-cr2)
                        tmp1 = -1*flip/(cr1-cr2)
                        tmp2 = flip/(cr1-cr2) - 1/(cr1-cr2)
                        flip_err = tmp0^2*err_cr0^2 + tmp1^2*err_cr1^2 +tmp2^2*err_cr2^2
                        flip_err = sqrt(flip_err)
                        
                        
                        
                        Printf "Flipping ratio = %g +/- %g (%g%)\r",flip,flip_err,flip_err/flip*100
                        str = num2str(flip)+" +/- "+num2str(flip_err)
                        SetVariable setvar3,value=_STR:str
                        
                        break
                case -1: // control being killed
                        break
        endswitch

        return 0
End


/////////////////////////////////////