Changeset 128 for sans/Analysis/branches/ajj_23APR07

Timestamp:

Jul 25, 2007 3:07:20 PM (16 years ago)

Author:

srkline

Message:

Second round of changes to ipf files to (hopefully) complete the changes to bring all of the model functions to be:

• this set of changes is for the "2006" set of models
• AAO
• new dependencies
• smearing using structures
• #if conditional compile for XOPS

-this needs to be FULLY tested for correctness and bugs
-packages are certainly still broken (data folders)

SRK 25 JUL 07

Location:

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006

Files:

• Beaucage.ipf (modified) (17 diffs)
• BimodalSchulzSpheres.ipf (modified) (7 diffs)
• BinaryHardSpheres.ipf (modified) (9 diffs)
• Cylinder_PolyLength.ipf (modified) (7 diffs)
• Cylinder_PolyRadius.ipf (modified) (6 diffs)
• Debye.ipf (modified) (5 diffs)
• EllipticalCylinder.ipf (modified) (6 diffs)
• FlexCyl_EllipCross.ipf (modified) (5 diffs)
• FlexCyl_PolyLen.ipf (modified) (7 diffs)
• FlexCyl_PolyRadius.ipf (modified) (7 diffs)
• FlexibleCylinder.ipf (modified) (5 diffs)
• Fractal.ipf (modified) (6 diffs)
• GaussSpheres.ipf (modified) (7 diffs)
• GaussSpheres_and_Struct.ipf (modified) (21 diffs)
• LamellarFF.ipf (modified) (6 diffs)
• LamellarFF_HG.ipf (modified) (6 diffs)
• LamellarPS.ipf (modified) (4 diffs)
• LamellarPS_HG.ipf (modified) (4 diffs)
• LogNormSpheres_and_Struct.ipf (modified) (20 diffs)
• LogNormalSphere.ipf (modified) (8 diffs)
• MultiShell.ipf (modified) (5 diffs)
• Parallelepiped.ipf (modified) (5 diffs)
• PolyCoreShellCylinder.ipf (modified) (6 diffs)
• SchulzSpheres.ipf (modified) (7 diffs)
• SchulzSpheres_and_Struct.ipf (modified) (21 diffs)
• TriaxialEllipsoid.ipf (modified) (6 diffs)
• Vesicle_UL.ipf (modified) (6 diffs)
• Vesicle_UL_and_Struct.ipf (modified) (21 diffs)

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/Beaucage.ipf

@@ -25 +25 @@
         make/o/t parameters_b1 = {"scale","G1 (cm-1 sr-1)","Rg1  (A)","B1 (cm-1 sr-1)","Pow1","bkg (cm-1 sr-1)"}
         Edit parameters_b1,coef_b1
-        ywave_b1 := OneLevel(coef_b1,xwave_b1)
+        
+        Variable/G root:g_b1
+        g_b1 := OneLevel(coef_b1,ywave_b1,xwave_b1)
         Display ywave_b1 vs xwave_b1
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -44 +46 @@
         make/o/t parameters_b2 = {"scale","G1 (cm-1 sr-1)","Rg1  (A)","B1 (cm-1 sr-1)","Pow1","G2 (cm-1 sr-1)","Rg2  (A)","B2 (cm-1 sr-1)","Pow2","bkg (cm-1 sr-1)"}
         Edit parameters_b2,coef_b2
-        ywave_b2 := TwoLevel(coef_b2,xwave_b2)
+        
+        Variable/G root:g_b2
+        g_b2 := TwoLevel(coef_b2,ywave_b2,xwave_b2)
         Display ywave_b2 vs xwave_b2
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -63 +67 @@
         make/o/t parameters_b3 = {"scale","G1 (cm-1 sr-1)","Rg1  (A)","B1 (cm-1 sr-1)","Pow1","G2 (cm-1 sr-1)","Rg2  (A)","B2 (cm-1 sr-1)","Pow2","G3 (cm-1 sr-1)","Rg3  (A)","B3 (cm-1 sr-1)","Pow3","bkg (cm-1)"}
         Edit parameters_b3,coef_b3
-        ywave_b3 := ThreeLevel(coef_b3,xwave_b3)
+        
+        Variable/G root:g_b3
+        g_b3 := ThreeLevel(coef_b3,ywave_b3,xwave_b3)   
         Display ywave_b3 vs xwave_b3
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -82 +88 @@
         make/o/t parameters_b4 = {"scale","G1 (cm-1 sr-1)","Rg1  (A)","B1 (cm-1 sr-1)","Pow1","G2 (cm-1 sr-1)","Rg2  (A)","B2 (cm-1 sr-1)","Pow2","G3 (cm-1 sr-1)","Rg3  (A)","B3 (cm-1 sr-1)","Pow3","G4 (cm-1 sr-1)","Rg4  (A)","B4 (cm-1 sr-1)","Pow4","bkg (cm-1)"}
         Edit parameters_b4,coef_b4
-        ywave_b4 := FourLevel(coef_b4,xwave_b4)
+        
+        Variable/G root:g_b4
+        g_b4 := FourLevel(coef_b4,ywave_b4,xwave_b4)    
         Display ywave_b4 vs xwave_b4
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -92 +100 @@
 /////////// macros for smeared model calculations
 
-Proc PlotSmearedBeau_OneLevel()                                                         
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        If(ResolutionWavesMissing())            //part of GaussUtils
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedBeau_OneLevel(str)                                                              
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -106 +119 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_b1,smeared_qvals                            
+        Duplicate/O $(str+"_q") smeared_b1,smeared_qvals                                
         SetScale d,0,0,"1/cm",smeared_b1                                                        
-
-        smeared_b1 := SmearedOneLevel(smear_coef_b1,$gQvals)            
+                                        
+        Variable/G gs_b1=0
+        gs_b1 := fSmearedOneLevel(smear_coef_b1,smeared_b1,smeared_qvals)       //this wrapper fills the STRUCT
+        
         Display smeared_b1 vs smeared_qvals                                                                     
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -115 +130 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Proc PlotSmearedBeau_TwoLevel()                                                         
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        If(ResolutionWavesMissing())            //part of GaussUtils
+        
+        SetDataFolder root:
+End
+        
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedBeau_TwoLevel(str)                                                              
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -131 +153 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_b2,smeared_qvals                            
+        Duplicate/O $(str+"_q") smeared_b2,smeared_qvals                                
         SetScale d,0,0,"1/cm",smeared_b2                                                        
-
-        smeared_b2 := SmearedTwoLevel(smear_coef_b2,$gQvals)            
+                                        
+        Variable/G gs_b2=0
+        gs_b2 := fSmearedTwoLevel(smear_coef_b2,smeared_b2,smeared_qvals)       //this wrapper fills the STRUCT
+        
         Display smeared_b2 vs smeared_qvals                                                                     
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -140 +164 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Proc PlotSmearedBeau_ThreeLevel()                                                               
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        If(ResolutionWavesMissing())            //part of GaussUtils
+        
+        SetDataFolder root:
+End
+        
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedBeau_ThreeLevel(str)                                                            
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -156 +187 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_b3,smeared_qvals                            
+        Duplicate/O $(str+"_q") smeared_b3,smeared_qvals                                
         SetScale d,0,0,"1/cm",smeared_b3                                                        
-
-        smeared_b3 := SmearedThreeLevel(smear_coef_b3,$gQvals)          
+                                        
+        Variable/G gs_b3=0
+        gs_b3 := fSmearedThreeLevel(smear_coef_b3,smeared_b3,smeared_qvals)     //this wrapper fills the STRUCT
+        
         Display smeared_b3 vs smeared_qvals                                                                     
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -165 +198 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Proc PlotSmearedBeau_FourLevel()                                                                
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        If(ResolutionWavesMissing())            //part of GaussUtils
+        
+        SetDataFolder root:
+End
+        
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedBeau_FourLevel(str)                                                             
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -181 +221 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_b4,smeared_qvals                            
+        Duplicate/O $(str+"_q") smeared_b4,smeared_qvals                                
         SetScale d,0,0,"1/cm",smeared_b4                                                        
-
-        smeared_b4 := SmearedFourLevel(smear_coef_b4,$gQvals)           
+                                        
+        Variable/G gs_b4=0
+        gs_b4 := fSmearedFourLevel(smear_coef_b4,smeared_b4,smeared_qvals)      //this wrapper fills the STRUCT
+        
         Display smeared_b4 vs smeared_qvals                                                                     
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -190 +232 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
+        
+        SetDataFolder root:
+End
+        
+
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function OneLevel(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("OneLevelX")
+        yw = OneLevelX(cw,xw)
+#else
+        yw = fOneLevel(cw,xw)
+#endif
+        return(0)
 End
 
 //////////Function definitions
 
-Function OneLevel(w,x) :FitFunc
+Function fOneLevel(w,x) :FitFunc
         Wave w
         Variable x
@@ -218 +279 @@
 End
 
-Function TwoLevel(w,x) :FitFunc
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function TwoLevel(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("TwoLevelX")
+        yw = TwoLevelX(cw,xw)
+#else
+        yw = fTwoLevel(cw,xw)
+#endif
+        return(0)
+End
+
+Function fTwoLevel(w,x) :FitFunc
         Wave w
         Variable x
@@ -251 +326 @@
 End
 
-
-Function ThreeLevel(w,x) :FitFunc
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function ThreeLevel(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("ThreeLevelX")
+        yw = ThreeLevelX(cw,xw)
+#else
+        yw = fThreeLevel(cw,xw)
+#endif
+        return(0)
+End
+
+Function fThreeLevel(w,x) :FitFunc
         Wave w
         Variable x
@@ -290 +378 @@
 End
 
-Function FourLevel(w,x) :FitFunc
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function FourLevel(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("FourLevelX")
+        yw = FourLevelX(cw,xw)
+#else
+        yw = fFourLevel(cw,xw)
+#endif
+        return(0)
+End
+
+Function fFourLevel(w,x) :FitFunc
         Wave w
         Variable x
@@ -334 +436 @@
 End
 
-Function SmearedOneLevel(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-//      Variable timer=StartMSTimer
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        ans = Smear_Model_20(OneLevel,$sq,$qb,$sh,$gQ,w,x)      
-
-//      Print "HS elapsed time(s) = ",StopMSTimer(timer)*1e-6
-        return(ans)
-End
-
-Function SmearedTwoLevel(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        ans = Smear_Model_20(TwoLevel,$sq,$qb,$sh,$gQ,w,x)      
-
-        return(ans)
-End
-
-Function SmearedThreeLevel(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        ans = Smear_Model_20(ThreeLevel,$sq,$qb,$sh,$gQ,w,x)    
-
-        return(ans)
-End
-
-Function SmearedFourLevel(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        ans = Smear_Model_20(FourLevel,$sq,$qb,$sh,$gQ,w,x)     
-
-        return(ans)
-End
+Function SmearedOneLevel(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(OneLevel,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+        
+
+Function SmearedTwoLevel(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(TwoLevel,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+        
+
+Function SmearedThreeLevel(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(ThreeLevel,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+
+Function SmearedFourLevel(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(FourLevel,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedOneLevel(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedOneLevel(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedTwoLevel(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedTwoLevel(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedThreeLevel(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedThreeLevel(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedFourLevel(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedFourLevel(fs)
+        
+        return (0)
+End

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/BimodalSchulzSpheres.ipf

@@ -26 +26 @@
         parameters_bss[4,9] = {"volume fraction(2)","Radius (2)","polydispersity(2)","SLD(2)","SLD (solvent)","background (cm-1 sr-1)"}
         Edit parameters_bss,coef_bss
-        ywave_bss := BimodalSchulzSpheres(coef_bss,xwave_bss)
+        
+        Variable/G root:g_bss
+        g_bss := BimodalSchulzSpheres(coef_bss,ywave_bss,xwave_bss)
         Display ywave_bss vs xwave_bss
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -36 +38 @@
 
 ///////////////////////////////////////////////////////////
-
-Proc PlotSmearedBimodalSchulzSpheres()          
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedBimodalSchulzSpheres(str)                                                               
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -55 +59 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_bss,smeared_qvals
+        Duplicate/O $(str+"_q") smeared_bss,smeared_qvals
         SetScale d,0,0,"1/cm",smeared_bss
-
-        smeared_bss := SmearedBimodalSchulzSpheres(smear_coef_bss,$gQvals)
+                                        
+        Variable/G gs_bss=0
+        gs_bss := fSmearedBimodalSchulzSpheres(smear_coef_bss,smeared_bss,smeared_qvals)        //this wrapper fills the STRUCT
+        
         Display smeared_bss vs smeared_qvals
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -64 +70 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
+        
+        SetDataFolder root:
+End
+        
 
 //  Calculates some characteristic parameters for bimodal Shulz distribution
@@ -170 +179 @@
 // unsmeared model calculation
 ///////////////////////////
-Function BimodalSchulzSpheres(w,k) : FitFunc
-        Wave w                  // the coefficient wave
-        Variable k              // the x values, as a variable
+// now AAO function
+Function BimodalSchulzSpheres(w,yw,xw) : FitFunc
+        Wave w,yw,xw                    // the coefficient wave, y, x
 
         Variable ans=0
@@ -192 +201 @@
         
         //calculate both models and sum (add background here)
-        ans = SchulzSpheres(temp_coef_1,k)
-        ans += SchulzSpheres(temp_coef_2,k)
-        ans += w[9]             //background
-        
-        return(ans)
+        Duplicate/O xw tmp_ss1,tmp_ss2
+        SchulzSpheres(temp_coef_1,tmp_ss1,xw)
+        SchulzSpheres(temp_coef_2,tmp_ss2,xw)
+        yw = tmp_ss1 + tmp_ss2
+        yw += w[9]              //background
+        
+        return(0)
 End
 
@@ -208 +219 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedBimodalSchulzSpheres(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedBimodalSchulzSpheres(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearedBimodalSchulzSpheres(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(BimodalSchulzSpheres,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
-
+Function SmearedBimodalSchulzSpheres(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(BimodalSchulzSpheres,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+        
+
+

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/BinaryHardSpheres.ipf

@@ -58 +58 @@
         ModifyTable width(coef_BinaryHS)=90
         
-        ywave_BinaryHS  := BinaryHS(coef_BinaryHS, xwave_BinaryHS)
+        Variable/G root:g_BinaryHS
+        g_BinaryHS := BinaryHS(coef_BinaryHS, ywave_BinaryHS,xwave_BinaryHS)
         Display ywave_BinaryHS vs xwave_BinaryHS
         ModifyGraph marker=29, msize=2, mode=4
@@ -67 +68 @@
 End
 
-//
-//this macro sets up all the necessary parameters and waves that are
-//needed to calculate the  smeared model function.
-//
-//no input parameters are necessary, it MUST use the experimental q-values
-// from the experimental data read in from an AVE/QSIG data file
-////////////////////////////////////////////////////
-Proc PlotSmeared_BinaryHS()                                                             //BinaryHS
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmeared_BinaryHS(str)                                                          
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -89 +88 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_BinaryHS,smeared_qvals                              //
+        Duplicate/O $(str+"_q") smeared_BinaryHS,smeared_qvals                          //
         SetScale d,0,0,"1/cm",smeared_BinaryHS                                                  //
-
-        smeared_BinaryHS := BinaryHS_Smeared(smear_coef_BinaryHS,$gQvals)               // SMEARED function name
+                                        
+        Variable/G gs_BinaryHS=0
+        gs_BinaryHS := fBinaryHS_Smeared(smear_coef_BinaryHS,smeared_BinaryHS,smeared_qvals)    //this wrapper fills the STRUCT
+        
         Display smeared_BinaryHS vs smeared_qvals                                                                       //
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -98 +99 @@
         Label left "I(q) (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End     // end macro 
+        
+        SetDataFolder root:
+End
+
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function BinaryHS(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("BinaryHSX")
+        yw = BinaryHSX(cw,xw)
+#else
+        yw = fBinaryHS(cw,xw)
+#endif
+        return(0)
+End
+
 
 //CH#1
@@ -105 +125 @@
 // based on the wave (array) of parameters that you send it (w)
 //
-Function BinaryHS(w,x) : FitFunc
+Function fBinaryHS(w,x) : FitFunc
         Wave w
         Variable x
@@ -168 +188 @@
 End
 
-Function BinaryHS_PSF11(w,x) : FitFunc
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function BinaryHS_PSF11(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("BinaryHS_PSF11X")
+        yw = BinaryHS_PSF11X(cw,xw)
+#else
+        yw = fBinaryHS_PSF11(cw,xw)
+#endif
+        return(0)
+End
+
+Function fBinaryHS_PSF11(w,x) : FitFunc
         Wave w
         Variable x
@@ -210 +244 @@
 End
 
-Function BinaryHS_PSF12(w,x) : FitFunc
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function BinaryHS_PSF12(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("BinaryHS_PSF12X")
+        yw = BinaryHS_PSF12X(cw,xw)
+#else
+        yw = fBinaryHS_PSF12(cw,xw)
+#endif
+        return(0)
+End
+
+Function fBinaryHS_PSF12(w,x) : FitFunc
         Wave w
         Variable x
@@ -252 +300 @@
 End
 
-Function BinaryHS_PSF22(w,x) : FitFunc
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function BinaryHS_PSF22(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("BinaryHS_PSF22X")
+        yw = BinaryHS_PSF22X(cw,xw)
+#else
+        yw = fBinaryHS_PSF22(cw,xw)
+#endif
+        return(0)
+End
+
+Function fBinaryHS_PSF22(w,x) : FitFunc
         Wave w
         Variable x
@@ -387 +449 @@
 End
         
-        
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fBinaryHS_Smeared(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = BinaryHS_Smeared(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function BinaryHS_Smeared(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(BinaryHS,$sq,$qb,$sh,$gQ,w,x)      //CH#4
-
-        return(ans)
-End
+Function BinaryHS_Smeared(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(BinaryHS,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+
 
 

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/Cylinder_PolyLength.ipf

@@ -28 +28 @@
         make/o/t parameters_cypl = {"scale","radius (A)","length (A)","polydispersity of Length","SLD diff (A^-2)","incoh. bkg (cm^-1)"}
         Edit parameters_cypl,coef_cypl
-        ywave_cypl := Cyl_PolyLength(coef_cypl,xwave_cypl)
+        
+        Variable/G root:g_cypl
+        g_cypl := Cyl_PolyLength(coef_cypl,ywave_cypl,xwave_cypl)
         Display ywave_cypl vs xwave_cypl
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -36 +38 @@
 End
 
-// plot the smeared version - quite slow - use only for final fit
-Proc PlotSmearedCyl_PolyLength()        
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedCyl_PolyLength(str)                                                             
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -53 +57 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_cypl,smeared_qvals
+        Duplicate/O $(str+"_q") smeared_cypl,smeared_qvals
         SetScale d,0,0,"1/cm",smeared_cypl      
-
-        smeared_cypl := SmearedCyl_PolyLength(smear_coef_cypl,$gQvals)
+                                        
+        Variable/G gs_cypl=0
+        gs_cypl := fSmearedCyl_PolyLength(smear_coef_cypl,smeared_cypl,smeared_qvals)   //this wrapper fills the STRUCT
+        
         Display smeared_cypl vs smeared_qvals
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -62 +68 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
+        
+        SetDataFolder root:
+End
+        
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function Cyl_PolyLength(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("Cyl_PolyLengthX")
+        yw = Cyl_PolyLengthX(cw,xw)
+#else
+        yw = fCyl_PolyLength(cw,xw)
+#endif
+        return(0)
 End
 
@@ -67 +91 @@
 // both integrals are done using quadrature, although both may benefit from an
 // adaptive integration
-Function Cyl_PolyLength(w,x)  : FitFunc
+Function fCyl_PolyLength(w,x)  : FitFunc
         Wave w
         Variable x
@@ -182 +206 @@
         kp[4] = 0               //bkg fixed at 0
         
-        Pq = CylinderForm(kp,qw)
-        //Pq = CylinderFit(kp,qw)       //from the XOP
+#if exists("CylinderFormX")
+        Pq = CylinderFormX(kp,qw)
+#else
+        Pq = fCylinderForm(kp,qw)
+#endif
         
         // undo the normalization that CylinderForm does
@@ -208 +235 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedCyl_PolyLength(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedCyl_PolyLength(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearedCyl_PolyLength(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(Cyl_PolyLength,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
+Function SmearedCyl_PolyLength(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(Cyl_PolyLength,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+        

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/Cylinder_PolyRadius.ipf

@@ -28 +28 @@
         make/o/t parameters_cypr = {"scale","radius (A)","length (A)","polydispersity of Radius","SLD diff (A^-2)","incoh. bkg (cm^-1)"}
         Edit parameters_cypr,coef_cypr
-        ywave_cypr := Cyl_PolyRadius(coef_cypr,xwave_cypr)
+        
+        Variable/G root:g_cypr
+        g_cypr := Cyl_PolyRadius(coef_cypr,ywave_cypr,xwave_cypr)
         Display ywave_cypr vs xwave_cypr
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -37 +39 @@
 
 ///////////////////////////////////////////////////////////
-
-Proc PlotSmearedCyl_PolyRadius()        
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedCyl_PolyRadius(str)                                                             
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -54 +58 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_cypr,smeared_qvals
+        Duplicate/O $(str+"_q") smeared_cypr,smeared_qvals
         SetScale d,0,0,"1/cm",smeared_cypr      
-
-        smeared_cypr := SmearedCyl_PolyRadius(smear_coef_cypr,$gQvals)
+                                        
+        Variable/G gs_cypr=0
+        gs_cypr := fSmearedCyl_PolyRadius(smear_coef_cypr,smeared_cypr,smeared_qvals)   //this wrapper fills the STRUCT
+        
         Display smeared_cypr vs smeared_qvals
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -63 +69 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function Cyl_PolyRadius(w,x) :FitFunc
+        
+        SetDataFolder root:
+End
+        
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function Cyl_PolyRadius(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("Cyl_PolyRadiusX")
+        yw = Cyl_PolyRadiusX(cw,xw)
+#else
+        yw = fCyl_PolyRadius(cw,xw)
+#endif
+        return(0)
+End
+
+Function fCyl_PolyRadius(w,x) :FitFunc
         Wave w
         Variable x
@@ -185 +209 @@
         kp[4] = 0               //bkg fixed at 0
         
-        Pq = CylinderForm(kp,qw)
-//      Pq = CylinderFormX(kp,qw)       //from the XOP
+#if exists("CylinderFormX")
+        Pq = CylinderFormX(kp,qw)
+#else
+        Pq = fCylinderForm(kp,qw)
+#endif
         
         // undo the normalization that CylinderForm does
@@ -210 +237 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedCyl_PolyRadius(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedCyl_PolyRadius(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearedCyl_PolyRadius(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(Cyl_PolyRadius,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
+Function SmearedCyl_PolyRadius(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(Cyl_PolyRadius,s.coefW,s.xW,s.resW)
+
+        return(0)
+End

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/Debye.ipf

@@ -15 +15 @@
         make/O/T parameters_deb = {"scale","Rg (A)","bkg (cm-1)"}
         Edit parameters_deb,coef_deb
-        ywave_deb := Debye(coef_deb,xwave_deb)
+        
+        Variable/G root:g_deb
+        g_deb := Debye(coef_deb,ywave_deb,xwave_deb)
         Display ywave_deb vs xwave_deb
         ModifyGraph marker=29,msize=2,mode=4,log=1
@@ -24 +26 @@
 
 ///////////////////////////////////////////////////////////
-Proc PlotSmearedDebye()
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedDebye(str)                                                              
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
         
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -39 +44 @@
         
         // output smeared intensity wave
-        Duplicate/O $gQvals smeared_deb,smeared_qvals
+        Duplicate/O $(str+"_q") smeared_deb,smeared_qvals
         SetScale d,0,0,"1/cm",smeared_deb
-
-        smeared_deb := SmearedDebye(smear_coef_deb,$gQvals)
+                                        
+        Variable/G gs_deb=0
+        gs_deb := fSmearedDebye(smear_coef_deb,smeared_deb,smeared_qvals)       //this wrapper fills the STRUCT
+        
         Display smeared_deb vs smeared_qvals
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -48 +55 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
+        
+        SetDataFolder root:
 End
+        
+
 ///////////////////////////////////////////////////////////////
 
 
-Function Debye(w,x) : FitFunc
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function Debye(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("DebyeX")
+        yw = DebyeX(cw,xw)
+#else
+        yw = fDebye(cw,xw)
+#endif
+        return(0)
+End
+
+Function fDebye(w,x) : FitFunc
         Wave w
         Variable x
@@ -78 +103 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedDebye(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedDebye(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearedDebye(w,x) :FitFunc
-        Wave w
-        Variable x
+Function SmearedDebye(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(Debye,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
         
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(Debye,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/EllipticalCylinder.ipf

@@ -30 +30 @@
         make/o/t parameters_ecf = {"scale","minor radius (A)","nu = major/minor (-)","length ()","SLD diff (A^-2)","incoh. bkg (cm^-1)"}
         Edit parameters_ecf,coef_ecf
-        ywave_ecf := EllipCylForm(coef_ecf,xwave_ecf)
+        
+        Variable/G root:g_ecf
+        g_ecf := EllipCyl20(coef_ecf,ywave_ecf,xwave_ecf)
         Display ywave_ecf vs xwave_ecf
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -39 +41 @@
 ///////////////////////////////////////////////////////////
 
-Proc PlotSmearedEllipCylForm()  
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedEllipCylForm(str)                                                               
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -55 +60 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_ecf,smeared_qvals
+        Duplicate/O $(str+"_q") smeared_ecf,smeared_qvals
         SetScale d,0,0,"1/cm",smeared_ecf       
-
-        smeared_ecf := SmearedEllipCylForm(smear_coef_ecf,$gQvals)
+                                        
+        Variable/G gs_ecf=0
+        gs_ecf := fSmearedEllipCylForm(smear_coef_ecf,smeared_ecf,smeared_qvals)        //this wrapper fills the STRUCT
+        
         Display smeared_ecf vs smeared_qvals
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -64 +71 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
+        
+        SetDataFolder root:
+End
+
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function EllipCyl20(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("EllipCyl20X")
+        yw = EllipCyl20X(cw,xw)
+#else
+        yw = fEllipCyl20(cw,xw)
+#endif
+        return(0)
 End
 
@@ -70 +95 @@
 // 20 points of quadrature seems to be sufficient for both integrals
 //
-Function EllipCylForm(w,x)      : FitFunc
+Function fEllipCyl20(w,x)       : FitFunc
         Wave w
         Variable x
@@ -139 +164 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedEllipCylForm(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedEllipCylForm(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearedEllipCylForm(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(EllipCylForm,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
+Function SmearedEllipCylForm(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(EllipCyl20,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+        

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/FlexCyl_EllipCross.ipf

@@ -27 +27 @@
         make/o/t parameters_fleell = {"scale","Contour Length (A)","Kuhn Length, b (A)","Minor Radius (a) (A)","Axis Ratio = major/a","contrast (A^-2)","bkgd (arb)"}
         Edit parameters_fleell,coef_fleell
-        ywave_fleell := FlexCyl_Ellip(coef_fleell,xwave_fleell)
+        
+        Variable/G root:g_fleell
+        g_fleell := FlexCyl_Ellip(coef_fleell,ywave_fleell,xwave_fleell)
         Display ywave_fleell vs xwave_fleell
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -35 +37 @@
 End
 
-//setup the smeared model calculation
-//
-Proc PlotSmeared_FlexCyl_Ellip()        
-        // if no gQvals wave, data must not have been loaded => abort
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmeared_FlexCyl_Ellip(str)                                                             
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
         
-        if(ResolutionWavesMissing())
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -51 +56 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_fleell,smeared_qvals                                //
+        Duplicate/O $(str+"_q") smeared_fleell,smeared_qvals                            //
         SetScale d,0,0,"1/cm",smeared_fleell                                                    //
-
-        smeared_fleell := SmearedFlexCyl_Ellip(smear_coef_fleell,$gQvals)               // SMEARED function name
+                                        
+        Variable/G gs_fleell=0
+        gs_fleell := fSmearedFlexCyl_Ellip(smear_coef_fleell,smeared_fleell,smeared_qvals)      //this wrapper fills the STRUCT
+        
         Display smeared_fleell vs smeared_qvals                                                                 //
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -60 +67 @@
         Label left "I(q) (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End     // end macro 
+        
+        SetDataFolder root:
+End
+        
 
 
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function FlexCyl_Ellip(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("FlexCyl_EllipX")
+        yw = FlexCyl_EllipX(cw,xw)
+#else
+        yw = fFlexCyl_Ellip(cw,xw)
+#endif
+        return(0)
+End
+
 //
-Function FlexCyl_Ellip(ww,x) :FitFunc
+Function fFlexCyl_Ellip(ww,x) :FitFunc
         Wave ww
         Variable x
@@ -124 +149 @@
 End
 
-// this is all there is to the smeared calculation!
-Function SmearedFlexCyl_Ellip(w,x) :FitFunc
-        Wave w
-        Variable x
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedFlexCyl_Ellip(coefW,yW,xW)
+        Wave coefW,yW,xW
         
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
         
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(FlexCyl_Ellip,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedFlexCyl_Ellip(fs)
+        
+        return (0)
 End
 
+// this is all there is to the smeared calculation!
+Function SmearedFlexCyl_Ellip(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(FlexCyl_Ellip,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+
+

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/FlexCyl_PolyLen.ipf

@@ -20 +20 @@
         make/o/t parameters_flepl =  {"scale","Contour Length (A)","polydispersity of Contour Length","Kuhn Length, b (A)","Radius (A)","contrast (A^-2)","bkgd (cm^-1)"}
         Edit parameters_flepl,coef_flepl
-        ywave_flepl := FlexCyl_PolyLen(coef_flepl,xwave_flepl)
+        
+        Variable/G root:g_flepl
+        g_flepl := FlexCyl_PolyLen(coef_flepl,ywave_flepl,xwave_flepl)
         Display ywave_flepl vs xwave_flepl
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -28 +30 @@
 End
 
-Proc PlotSmeared_FlexCyl_PolyLen()                                                              //MyModel
-        // if no gQvals wave, data must not have been loaded => abort
-        
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmeared_FlexCyl_PolyLen(str)                                                           
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -42 +49 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_flepl,smeared_qvals                         //
+        Duplicate/O $(str+"_q") smeared_flepl,smeared_qvals                             //
         SetScale d,0,0,"1/cm",smeared_flepl                                                     //
-
-        smeared_flepl := SmearedFlexCyl_PolyLen(smear_coef_flepl,$gQvals)               // SMEARED function name
+                                        
+        Variable/G gs_flepl=0
+        gs_flepl := fSmearedFlexCyl_PolyLen(smear_coef_flepl,smeared_flepl,smeared_qvals)       //this wrapper fills the STRUCT
+        
         Display smeared_flepl vs smeared_qvals                                                                  //
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -51 +60 @@
         Label left "I(q) (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End     // end macro 
+        
+        SetDataFolder root:
+End
+        
 
 Function Schulz_Point_flepl(x,avg,zz)
@@ -65 +77 @@
 End
 
-Function FlexCyl_PolyLen(w,x) : FitFunc
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function FlexCyl_PolyLen(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("FlexCyl_PolyLenX")
+        yw = FlexCyl_PolyLenX(cw,xw)
+#else
+        yw = fFlexCyl_PolyLen(cw,xw)
+#endif
+        return(0)
+End
+
+Function fFlexCyl_PolyLen(w,x) : FitFunc
         Wave w
         Variable x
@@ -172 +199 @@
         kp[5] = 0               //bkg fixed at 0
         
-        Pq = FlexExclVolCyl(kp,qw)
+#if exists("FlexExclVolCylX")
+        Pq = FlexExclVolCylX(kp,qw)
+#else
+        Pq = fFlexExclVolCyl(kp,qw)
+#endif
+        
         vcyl=Pi*rad*rad*len_i
         Pq *= vcyl
@@ -182 +214 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedFlexCyl_PolyLen(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedFlexCyl_PolyLen(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearedFlexCyl_PolyLen(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(FlexCyl_PolyLen,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
+Function SmearedFlexCyl_PolyLen(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(FlexCyl_PolyLen,s.coefW,s.xW,s.resW)
+
+        return(0)
+End

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/FlexCyl_PolyRadius.ipf

@@ -18 +18 @@
         make/o/t parameters_fcpr = {"scale","Contour Length (A)","Kuhn Length, b (A)","Radius (A)","polydispersity of radius","contrast (A^-2)","bkgd (cm^-1)"}
         Edit parameters_fcpr,coef_fcpr
-        ywave_fcpr := FlexCylPolyRad(coef_fcpr,xwave_fcpr)
+        
+        Variable/G root:g_fcpr
+        g_fcpr := FlexCyl_PolyRad(coef_fcpr,ywave_fcpr,xwave_fcpr)
         Display ywave_fcpr vs xwave_fcpr
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -26 +28 @@
 End
 
-
-Proc PlotSmearedFlexCyl_PolyRad()                                                               
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedFlexCyl_PolyRad(str)                                                            
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -43 +47 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_fcpr,smeared_qvals                          
+        Duplicate/O $(str+"_q") smeared_fcpr,smeared_qvals                              
         SetScale d,0,0,"1/cm",smeared_fcpr                                                      
-
-        smeared_fcpr := SmearedFlexCyl_PolyRad(smear_coef_fcpr,$gQvals)         
+                                        
+        Variable/G gs_fcpr=0
+        gs_fcpr := fSmearedFlexCyl_PolyRad(smear_coef_fcpr,smeared_fcpr,smeared_qvals)  //this wrapper fills the STRUCT
+        
         Display smeared_fcpr vs smeared_qvals                                                                   
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -52 +58 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
+        
+        SetDataFolder root:
+End
+
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function FlexCyl_PolyRad(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("FlexCyl_PolyRadX")
+        yw = FlexCyl_PolyRadX(cw,xw)
+#else
+        yw = fFlexCyl_PolyRad(cw,xw)
+#endif
+        return(0)
 End
 
@@ -57 +81 @@
 // to account for the polydispersity of the radius.
 //
-Function FlexCylPolyRad(w,x)  : FitFunc
+Function fFlexCyl_PolyRad(w,x)  : FitFunc
         Wave w
         Variable x
@@ -180 +204 @@
         kp[5] = 0               //bkg fixed at 0
         
-        //Pq = CylinderForm(kp,qw)
-        Pq = FlexExclVolCyl(kp,qw)      //from the XOP
+#if exists("FlexExclVolCylX")
+        Pq = FlexExclVolCylX(kp,qw)
+#else
+        Pq = fFlexExclVolCyl(kp,qw)
+#endif
         
         // undo the normalization that the form factor does
@@ -205 +232 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedFlexCyl_PolyRad(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedFlexCyl_PolyRad(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearedFlexCyl_PolyRad(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(FlexCylPolyRad,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
+Function SmearedFlexCyl_PolyRad(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(FlexCyl_PolyRad,s.coefW,s.xW,s.resW)
+
+        return(0)
+End

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/FlexibleCylinder.ipf

@@ -30 +30 @@
         make/o/t parameters_fle = {"scale","Contour Length (A)","Kuhn Length, b (A)","Radius (A)","contrast (A^-2)","bkgd (cm^-1)"}
         Edit parameters_fle,coef_fle
-        ywave_fle := FlexExclVolCyl(coef_fle,xwave_fle)
+        
+        Variable/G root:g_fle
+        g_fle := FlexExclVolCyl(coef_fle,ywave_fle,xwave_fle)
         Display ywave_fle vs xwave_fle
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -39 +41 @@
 ///////////////////////////////////////////////////////////
 
-Proc PlotSmearedFlexExclVolCyl()                                                                
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedFlexExclVolCyl(str)                                                             
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -55 +60 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_fle,smeared_qvals                           
+        Duplicate/O $(str+"_q") smeared_fle,smeared_qvals                               
         SetScale d,0,0,"1/cm",smeared_fle                                                       
-
-        smeared_fle := SmearedFlexExclVolCyl(smear_coef_fle,$gQvals)            
+                                        
+        Variable/G gs_fle=0
+        gs_fle := fSmearedFlexExclVolCyl(smear_coef_fle,smeared_fle,smeared_qvals)      //this wrapper fills the STRUCT
+        
         Display smeared_fle vs smeared_qvals                                                                    
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -64 +71 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
+        
+        SetDataFolder root:
 End
-
-//
-Function FlexExclVolCyl(ww,x)
+        
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function FlexExclVolCyl(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("FlexExclVolCylX")
+        yw = FlexExclVolCylX(cw,xw)
+#else
+        yw = fFlexExclVolCyl(cw,xw)
+#endif
+        return(0)
+End
+
+//
+Function fFlexExclVolCyl(ww,x)
         Wave ww
         Variable x
@@ -468 +492 @@
 //////////////////
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedFlexExclVolCyl(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedFlexExclVolCyl(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearedFlexExclVolCyl(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(FlexExclVolCyl,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+Function SmearedFlexExclVolCyl(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(FlexExclVolCyl,s.coefW,s.xW,s.resW)
+
+        return(0)
 End

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/Fractal.ipf

@@ -20 +20 @@
         Make/O/D coef_fra = {0.05,5,2,100,2e-6,6.35e-6,0}                                               
         make/o/t parameters_fra = {"Volume Fraction (scale)","Block Radius (A)","fractal dimension","correlation length (A)","SLD block (A-2)","SLD solvent (A-2)","bkgd (cm^-1 sr^-1)"}                
-        Edit parameters_fra,coef_fra                                                            
-        ywave_fra := Fractal(coef_fra,xwave_fra)                        
+        Edit parameters_fra,coef_fra            
+        
+        Variable/G root:g_fra
+        g_fra := Fractal(coef_fra,ywave_fra,xwave_fra)                  
         Display ywave_fra vs xwave_fra                                                  
         ModifyGraph log=1,marker=29,msize=2,mode=4                      
@@ -29 +31 @@
 End
 
-Proc PlotSmearedFractal()
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedFractal(str)                                                            
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
         
-        // if no gQvals wave, data must not have been loaded => abort
-        If(ResolutionWavesMissing())            //part of GaussUtils
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -43 +50 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_fractal,smeared_qvals                               //
+        Duplicate/O $(str+"_q") smeared_fractal,smeared_qvals                           //
         SetScale d,0,0,"1/cm",smeared_fractal                                                   //
-
-        smeared_fractal := SmearedFractal(smear_coef_fractal,$gQvals)
+                                        
+        Variable/G gs_fractal=0
+        gs_fractal := fSmearedFractal(smear_coef_fractal,smeared_fractal,smeared_qvals) //this wrapper fills the STRUCT
+        
         Display smeared_fractal vs smeared_qvals                
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -52 +61 @@
         Label left "I(q) (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End     // end macro 
+        
+        SetDataFolder root:
+End
+
+
 
 //calculates the physical parameters related to the 
@@ -86 +99 @@
 End
 
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function Fractal(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("FractalX")
+        yw = FractalX(cw,xw)
+#else
+        yw = fFractal(cw,xw)
+#endif
+        return(0)
+End
+
 //fractal scattering function
-Function Fractal(w,x) :FitFunc
+Function fFractal(w,x) :FitFunc
         wave w
         variable x
@@ -114 +141 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedFractal(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedFractal(fs)
+        
+        return (0)
+End
+
 //the smeared model calculation
-Function SmearedFractal(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        ans = Smear_Model_20(Fractal,$sq,$qb,$sh,$gQ,w,x)       
+Function SmearedFractal(s) :FitFunc
+        Struct ResSmearAAOStruct &s
 
-        return(ans)
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(Fractal,s.coefW,s.xW,s.resW)
+
+        return(0)
 End

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/GaussSpheres.ipf

@@ -22 +22 @@
         make/O/T parameters_pgs = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","bkg (cm-1 sr-1)"}
         Edit parameters_pgs,coef_pgs
-        ywave_pgs := GaussPolySphere(coef_pgs,xwave_pgs)
+        
+        Variable/G root:g_pgs
+        g_pgs := GaussPolySphere(coef_pgs,ywave_pgs,xwave_pgs)
         Display ywave_pgs vs xwave_pgs
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -30 +32 @@
 End
 
-Proc PlotSmearedGaussPolySpheres()                                                              
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedGaussPolySpheres(str)                                                           
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -46 +51 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_pgs,smeared_qvals                           
+        Duplicate/O $(str+"_q") smeared_pgs,smeared_qvals                               
         SetScale d,0,0,"1/cm",smeared_pgs                                                       
-
-        smeared_pgs := SmearedGaussPolySphere(smear_coef_pgs,$gQvals)           
+                                        
+        Variable/G gs_pgs=0
+        gs_pgs := fSmearedGaussPolySphere(smear_coef_pgs,smeared_pgs,smeared_qvals)     //this wrapper fills the STRUCT
+        
         Display smeared_pgs vs smeared_qvals                                                                    
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -55 +62 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-
-Function GaussPolySphere(w,x) : FitFunc
+        
+        SetDataFolder root:
+End
+        
+
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function GaussPolySphere(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("GaussPolySphereX")
+        yw = GaussPolySphereX(cw,xw)
+#else
+        yw = fGaussPolySphere(cw,xw)
+#endif
+        return(0)
+End
+
+Function fGaussPolySphere(w,x) : FitFunc
         wave w
         variable x
@@ -122 +147 @@
         
         summ = 0.0              // initialize integral
+        Make/O/N=1 tmp_w
         for(ii=0;ii<nord;ii+=1)
                 // calculate Gauss points on integration interval (r-value for evaluation)
@@ -127 +153 @@
                 sphere_temp[1] = zi
                 // calculate sphere scattering
-                yy = gauWt[ii] *  Gauss_distr(sig,rad,zi) * SphereForm(sphere_temp,x)
+                SphereForm(sphere_temp,tmp_w,x)         // AAO calculation, one point
+                yy = gauWt[ii] *  Gauss_distr(sig,rad,zi) * tmp_w[0]
                 yy *= 4*pi/3*zi*zi*zi           //un-normalize by current sphere volume
                 
@@ -144 +171 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedGaussPolySphere(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedGaussPolySphere(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearedGaussPolySphere(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(GaussPolySphere,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
+Function SmearedGaussPolySphere(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(GaussPolySphere,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+
 
 

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/GaussSpheres_and_Struct.ipf

@@ -23 +23 @@
         make/O/T parameters_pgs_HS = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","bkg (cm-1 sr-1)"}
         Edit parameters_pgs_HS,coef_pgs_HS
-        ywave_pgs_HS := GaussPolySphere_HS(coef_pgs_HS,xwave_pgs_HS)
+        
+        Variable/G root:g_pgs_HS
+        g_pgs_HS := GaussPolySphere_HS(coef_pgs_HS,ywave_pgs_HS,xwave_pgs_HS)
         Display ywave_pgs_HS vs xwave_pgs_HS
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -31 +33 @@
 End
 
-Proc PlotSmearedGaussPolySphere_HS()                                                            
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedGaussPolySphere_HS(str)                                                         
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -47 +52 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_pgs_HS,smeared_qvals                                
+        Duplicate/O $(str+"_q") smeared_pgs_HS,smeared_qvals                            
         SetScale d,0,0,"1/cm",smeared_pgs_HS                                                    
-
-        smeared_pgs_HS := SmearedGaussPolySphere_HS(smear_coef_pgs_HS,$gQvals)          
+                                        
+        Variable/G gs_pgs_HS=0
+        gs_pgs_HS := fSmearedGaussPolySphere_HS(smear_coef_pgs_HS,smeared_pgs_HS,smeared_qvals) //this wrapper fills the STRUCT
+        
         Display smeared_pgs_HS vs smeared_qvals                                                                 
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -56 +63 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function GaussPolySphere_HS(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+
+
+
+Function GaussPolySphere_HS(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -88 +98 @@
         
         //calculate each and combine
-        inten = GaussPolySphere(form_pgs_HS,x)
-        inten *= HardSphereStruct(struct_pgs_HS,x)
-        inten *= w[0]
-        inten += w[5]
+        Duplicate/O xw tmp_pgs_HS_PQ,tmp_pgs_HS_SQ
+        GaussPolySphere(form_pgs_HS,tmp_pgs_HS_PQ,xw)
+        HardSphereStruct(struct_pgs_HS,tmp_pgs_HS_SQ,xw)
+        yw = tmp_pgs_HS_PQ * tmp_pgs_HS_SQ
+        yw *= w[0]
+        yw += w[5]
         
         //cleanup waves
 //      Killwaves/Z form_pgs_HS,struct_pgs_HS
         
-        return (inten)
+        return (0)
 End
 
@@ -111 +123 @@
         make/O/T parameters_pgs_SW = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","well depth (kT)","well width (diam.)","bkg (cm-1 sr-1)"}
         Edit parameters_pgs_SW,coef_pgs_SW
-        ywave_pgs_SW := GaussPolySphere_SW(coef_pgs_SW,xwave_pgs_SW)
+        
+        Variable/G root:g_pgs_SW
+        g_pgs_SW := GaussPolySphere_SW(coef_pgs_SW,ywave_pgs_SW,xwave_pgs_SW)
         Display ywave_pgs_SW vs xwave_pgs_SW
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -119 +133 @@
 End
 
-Proc PlotSmearedGaussPolySphere_SW()                                                            
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedGaussPolySphere_SW(str)                                                         
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -135 +152 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_pgs_SW,smeared_qvals                                
+        Duplicate/O $(str+"_q") smeared_pgs_SW,smeared_qvals                            
         SetScale d,0,0,"1/cm",smeared_pgs_SW                                                    
-
-        smeared_pgs_SW := SmearedGaussPolySphere_SW(smear_coef_pgs_SW,$gQvals)          
+                                        
+        Variable/G gs_pgs_SW=0
+        gs_pgs_SW := fSmearedGaussPolySphere_SW(smear_coef_pgs_SW,smeared_pgs_SW,smeared_qvals) //this wrapper fills the STRUCT
+        
         Display smeared_pgs_SW vs smeared_qvals                                                                 
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -144 +163 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function GaussPolySphere_SW(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+        
+
+Function GaussPolySphere_SW(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -177 +198 @@
         
         //calculate each and combine
-        inten = GaussPolySphere(form_pgs_SW,x)
-        inten *= SquareWellStruct(struct_pgs_SW,x)
-        inten *= w[0]
-        inten += w[7]
+        Duplicate/O xw tmp_pgs_SW_PQ,tmp_pgs_SW_SQ
+        GaussPolySphere(form_pgs_SW,tmp_pgs_SW_PQ,xw)
+        SquareWellStruct(struct_pgs_SW,tmp_pgs_SW_SQ,xw)
+        yw = tmp_pgs_SW_PQ * tmp_pgs_SW_SQ
+        yw *= w[0]
+        yw += w[7]
         
         //cleanup waves
 //      Killwaves/Z form_pgs_SW,struct_pgs_SW
         
-        return (inten)
+        return (0)
 End
 
@@ -208 +231 @@
         make/O/T parameters_pgs_SC = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","charge","movalent salt(M)","Temperature (K)","dielectric const","bkg (cm-1 sr-1)"}
         Edit parameters_pgs_SC,coef_pgs_SC
-        ywave_pgs_SC := GaussPolySphere_SC(coef_pgs_SC,xwave_pgs_SC)
+        
+        Variable/G root:g_pgs_SC
+        g_pgs_SC := GaussPolySphere_SC(coef_pgs_SC,ywave_pgs_SC,xwave_pgs_SC)
         Display ywave_pgs_SC vs xwave_pgs_SC
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -216 +241 @@
 End
 
-Proc PlotSmearedGaussPolySphere_SC()                                                            
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedGaussPolySphere_SC(str)                                                         
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
-
+        
+        SetDataFolder $("root:"+str)
+        
         if (DataFolderExists("root:HayPenMSA"))
                 Make/O/D/N=17 root:HayPenMSA:gMSAWave
@@ -239 +267 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_pgs_SC,smeared_qvals                                
+        Duplicate/O $(str+"_q") smeared_pgs_SC,smeared_qvals                            
         SetScale d,0,0,"1/cm",smeared_pgs_SC                                                    
-
-        smeared_pgs_SC := SmearedGaussPolySphere_SC(smear_coef_pgs_SC,$gQvals)          
+                                        
+        Variable/G gs_pgs_SC=0
+        gs_pgs_SC := fSmearedGaussPolySphere_SC(smear_coef_pgs_SC,smeared_pgs_SC,smeared_qvals) //this wrapper fills the STRUCT
+        
         Display smeared_pgs_SC vs smeared_qvals                                                                 
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -248 +278 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function GaussPolySphere_SC(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+
+
+Function GaussPolySphere_SC(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -283 +315 @@
         
         //calculate each and combine
-        inten = GaussPolySphere(form_pgs_SC,x)
-        inten *= HayterPenfoldMSA(struct_pgs_SC,x)
-        inten *= w[0]
-        inten += w[9]
+        Duplicate/O xw tmp_pgs_SC_PQ,tmp_pgs_SC_SQ
+        GaussPolySphere(form_pgs_SC,tmp_pgs_SC_PQ,xw)
+        HayterPenfoldMSA(struct_pgs_SC,tmp_pgs_SC_SQ,xw)
+        yw = tmp_pgs_SC_PQ * tmp_pgs_SC_SQ
+        yw *= w[0]
+        yw += w[9]
         
         //cleanup waves
 //      Killwaves/Z form_pgs_SC,struct_pgs_SC
         
-        return (inten)
+        return (0)
 End
 
@@ -306 +340 @@
         make/O/T parameters_pgs_SHS = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","perturbation parameter (0.1)","stickiness, tau","bkg (cm-1 sr-1)"}
         Edit parameters_pgs_SHS,coef_pgs_SHS
-        ywave_pgs_SHS := GaussPolySphere_SHS(coef_pgs_SHS,xwave_pgs_SHS)
+        
+        Variable/G root:g_pgs_SHS
+        g_pgs_SHS := GaussPolySphere_SHS(coef_pgs_SHS,ywave_pgs_SHS,xwave_pgs_SHS)
         Display ywave_pgs_SHS vs xwave_pgs_SHS
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -314 +350 @@
 End
 
-Proc PlotSmearedGaussPolySphere_SHS()                                                           
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedGaussPolySphere_SHS(str)                                                                
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -330 +369 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_pgs_SHS,smeared_qvals                               
+        Duplicate/O $(str+"_q") smeared_pgs_SHS,smeared_qvals                           
         SetScale d,0,0,"1/cm",smeared_pgs_SHS                                                   
-
-        smeared_pgs_SHS := SmearedGaussPolySphere_SHS(smear_coef_pgs_SHS,$gQvals)               
+                                        
+        Variable/G gs_pgs_SHS=0
+        gs_pgs_SHS := fSmearedGaussPolySphere_SHS(smear_coef_pgs_SHS,smeared_pgs_SHS,smeared_qvals)     //this wrapper fills the STRUCT
+        
         Display smeared_pgs_SHS vs smeared_qvals                                                                        
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -339 +380 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function GaussPolySphere_SHS(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+        
+
+Function GaussPolySphere_SHS(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -372 +415 @@
         
         //calculate each and combine
-        inten = GaussPolySphere(form_pgs_SHS,x)
-        inten *= StickyHS_Struct(struct_pgs_SHS,x)
-        inten *= w[0]
-        inten += w[7]
+        Duplicate/O xw tmp_pgs_SHS_PQ,tmp_pgs_SHS_SQ
+        GaussPolySphere(form_pgs_SHS,tmp_pgs_SHS_PQ,xw)
+        StickyHS_Struct(struct_pgs_SHS,tmp_pgs_SHS_SQ,xw)
+        yw = tmp_pgs_SHS_PQ * tmp_pgs_SHS_SQ
+        yw *= w[0]
+        yw += w[7]
         
         //cleanup waves
 //      Killwaves/Z form_pgs_SHS,struct_pgs_SHS
         
-        return (inten)
+        return (0)
 End
 
@@ -386 +431 @@
 
 // this is all there is to the smeared calculation!
-Function SmearedGaussPolySphere_HS(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(GaussPolySphere_HS,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+Function SmearedGaussPolySphere_HS(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(GaussPolySphere_HS,s.coefW,s.xW,s.resW)
+
+        return(0)
 End
 
 // this is all there is to the smeared calculation!
-Function SmearedGaussPolySphere_SW(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(GaussPolySphere_SW,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+Function SmearedGaussPolySphere_SW(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(GaussPolySphere_SW,s.coefW,s.xW,s.resW)
+
+        return(0)
 End
 
 // this is all there is to the smeared calculation!
-Function SmearedGaussPolySphere_SC(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(GaussPolySphere_SC,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+Function SmearedGaussPolySphere_SC(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(GaussPolySphere_SC,s.coefW,s.xW,s.resW)
+
+        return(0)
 End
 
 // this is all there is to the smeared calculation!
-Function SmearedGaussPolySphere_SHS(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(GaussPolySphere_SHS,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
+Function SmearedGaussPolySphere_SHS(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(GaussPolySphere_SHS,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedGaussPolySphere_HS(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedGaussPolySphere_HS(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedGaussPolySphere_SW(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedGaussPolySphere_SW(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedGaussPolySphere_SC(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedGaussPolySphere_SC(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedGaussPolySphere_SHS(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedGaussPolySphere_SHS(fs)
+        
+        return (0)
+End
+

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/LamellarFF.ipf

@@ -33 +33 @@
         Edit parameters_LamellarFF, coef_LamellarFF
         ModifyTable width(parameters_LamellarFF)=160
-        ywave_LamellarFF  := LamellarFF(coef_LamellarFF, xwave_LamellarFF)
+        
+        Variable/G root:g_LamellarFF
+        g_LamellarFF := LamellarFF(coef_LamellarFF, ywave_LamellarFF,xwave_LamellarFF)
         Display ywave_LamellarFF vs xwave_LamellarFF
         ModifyGraph marker=29, msize=2, mode=4
@@ -43 +45 @@
 End
 
-//
-//this macro sets up all the necessary parameters and waves that are
-//needed to calculate the  smeared model function.
-//
-//no input parameters are necessary, it MUST use the experimental q-values
-// from the experimental data read in from an AVE/QSIG data file
-////////////////////////////////////////////////////
-Proc PlotSmeared_LamellarFF()                                                           //Lamellar
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmeared_LamellarFF(str)                                                                
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
         
-        // if no gQvals wave, data must not have been loaded => abort
-        If(ResolutionWavesMissing())            //part of GaussUtils
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -64 +64 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_LamellarFF,smeared_qvals                            //
+        Duplicate/O $(str+"_q") smeared_LamellarFF,smeared_qvals                                //
         SetScale d,0,0,"1/cm",smeared_LamellarFF                                                        //
-
-        smeared_LamellarFF := LamellarFF_Smeared(smear_coef_LamellarFF,$gQvals)         // SMEARED function name
+                                        
+        Variable/G gs_LamellarFF=0
+        gs_LamellarFF := fLamellarFF_Smeared(smear_coef_LamellarFF,smeared_LamellarFF,smeared_qvals)    //this wrapper fills the STRUCT
+        
         Display smeared_LamellarFF vs smeared_qvals                                                                     //
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -73 +75 @@
         Label left "I(q) (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End     // end macro 
+        
+        SetDataFolder root:
+End
+////////////////////////////////////////////////////
+        
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function LamellarFF(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("LamellarFFX")
+        yw = LamellarFFX(cw,xw)
+#else
+        yw = fLamellarFF(cw,xw)
+#endif
+        return(0)
+End
 
 //CH#1
@@ -80 +101 @@
 // based on the wave (array) of parameters that you send it (w)
 //
-Function LamellarFF(w,x) : FitFunc
+Function fLamellarFF(w,x) : FitFunc
         Wave w
         Variable x
@@ -115 +136 @@
 End
 
-//the smeared model calculation
-Function LamellarFF_Smeared(w,x) :FitFunc
-        Wave w
-        Variable x
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fLamellarFF_Smeared(coefW,yW,xW)
+        Wave coefW,yW,xW
         
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
         
-        ans = Smear_Model_20(LamellarFF,$sq,$qb,$sh,$gQ,w,x)    
-
-        return(ans)
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = LamellarFF_Smeared(fs)
+        
+        return (0)
 End
 
+//the smeared model calculation
+Function LamellarFF_Smeared(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(LamellarFF,s.coefW,s.xW,s.resW)
+
+        return(0)
+End

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/LamellarFF_HG.ipf

@@ -35 +35 @@
         Edit parameters_LamellarFF_HG, coef_LamellarFF_HG
         ModifyTable width(parameters_LamellarFF_HG)=160
-        ywave_LamellarFF_HG  := LamellarFF_HG(coef_LamellarFF_HG, xwave_LamellarFF_HG)
+        
+        Variable/G root:g_LamellarFF_HG
+        g_LamellarFF_HG := LamellarFF_HG(coef_LamellarFF_HG, ywave_LamellarFF_HG, xwave_LamellarFF_HG)
         Display ywave_LamellarFF_HG vs xwave_LamellarFF_HG
         ModifyGraph marker=29, msize=2, mode=4
@@ -45 +47 @@
 End
 
-//
-//this macro sets up all the necessary parameters and waves that are
-//needed to calculate the  smeared model function.
-//
-//no input parameters are necessary, it MUST use the experimental q-values
-// from the experimental data read in from an AVE/QSIG data file
-////////////////////////////////////////////////////
-Proc PlotSmeared_LamellarFF_HG()                                                                //Lamellar
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmeared_LamellarFF_HG(str)                                                             
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
         
-        // if no gQvals wave, data must not have been loaded => abort
-        If(ResolutionWavesMissing())            //part of GaussUtils
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -66 +66 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_LamellarFF_HG,smeared_qvals                         //
+        Duplicate/O $(str+"_q") smeared_LamellarFF_HG,smeared_qvals                             //
         SetScale d,0,0,"1/cm",smeared_LamellarFF_HG                                                     //
-
-        smeared_LamellarFF_HG := LamellarFF_HG_Smeared(smear_coef_LamellarFF_HG,$gQvals)                // SMEARED function name
+                                        
+        Variable/G gs_LamellarFF_HG=0
+        gs_LamellarFF_HG := fLamellarFF_HG_Smeared(smear_coef_LamellarFF_HG,smeared_LamellarFF_HG,smeared_qvals)        //this wrapper fills the STRUCT
+        
         Display smeared_LamellarFF_HG vs smeared_qvals                                                                  //
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -75 +77 @@
         Label left "I(q) (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End     // end macro 
+        
+        SetDataFolder root:
+End
+
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function LamellarFF_HG(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("LamellarFF_HGX")
+        yw = LamellarFF_HGX(cw,xw)
+#else
+        yw = fLamellarFF_HG(cw,xw)
+#endif
+        return(0)
+End
 
 //CH#1
@@ -82 +102 @@
 // based on the wave (array) of parameters that you send it (w)
 //
-Function LamellarFF_HG(w,x) : FitFunc
+Function fLamellarFF_HG(w,x) : FitFunc
         Wave w
         Variable x
@@ -124 +144 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fLamellarFF_HG_Smeared(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = LamellarFF_HG_Smeared(fs)
+        
+        return (0)
+End
+
 //the smeared model calculation
-Function LamellarFF_HG_Smeared(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        ans = Smear_Model_20(LamellarFF_HG,$sq,$qb,$sh,$gQ,w,x) 
+Function LamellarFF_HG_Smeared(s) :FitFunc
+        Struct ResSmearAAOStruct &s
 
-        return(ans)
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(LamellarFF_HG,s.coefW,s.xW,s.resW)
+
+        return(0)
 End

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/LamellarPS.ipf

@@ -63 +63 @@
         Edit parameters_LamellarPS, coef_LamellarPS
         ModifyTable width(parameters_LamellarPS)=160
-        ywave_LamellarPS  := LamellarPS(coef_LamellarPS, xwave_LamellarPS)
+        
+        Variable/G root:g_LamellarPS
+        g_LamellarPS := LamellarPS(coef_LamellarPS, ywave_LamellarPS, xwave_LamellarPS)
         Display ywave_LamellarPS vs xwave_LamellarPS
         ModifyGraph marker=29, msize=2, mode=4
@@ -77 +79 @@
 End
 
-////
-////this macro sets up all the necessary parameters and waves that are
-////needed to calculate the  smeared model function.
-////
-////no input parameters are necessary, it MUST use the experimental q-values
-//// from the experimental data read in from an AVE/QSIG data file
-//////////////////////////////////////////////////////
-//Macro PlotSmeared_LamellarPS()                                                                //Lamellar
-//      
-//      
-//      // if no gQvals wave, data must not have been loaded => abort
-//      If(ResolutionWavesMissing())            //part of GaussUtils
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+//Proc PlotSmeared_LamellarPS(str)                                                              
+//      String str
+//      Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+//      
+//      // if any of the resolution waves are missing => abort
+//      if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
 //              Abort
 //      endif
+//      
+//      SetDataFolder $("root:"+str)
 //      
 //      // constants
@@ -102 +101 @@
 //      // output smeared intensity wave, dimensions are identical to experimental QSIG values
 //      // make extra copy of experimental q-values for easy plotting
-//      Duplicate/O $gQvals smeared_LamellarPS,smeared_qvals                            //
+//      Duplicate/O $(str+"_q") smeared_LamellarPS,smeared_qvals                                //
 //      SetScale d,0,0,"1/cm",smeared_LamellarPS                                                        //
-//
-//      smeared_LamellarPS := LamellarPS_Smeared(smear_coef_LamellarPS,$gQvals)         // SMEARED function name
-//      Display smeared_LamellarPS vs $gQvals                                                                   //
+//                                      
+//      Variable/G gs_LamellarPS=0
+//      gs_LamellarPS := fLamellarPS_Smeared(smear_coef_LamellarPS,smeared_LamellarPS,smeared_qvals)    //this wrapper fills the STRUCT
+//      
+//      Display smeared_LamellarPS vs smeared_qvals                                                                     //
 //      ModifyGraph log=1,marker=29,msize=2,mode=4
 //      Label bottom "q (\\S-1\\M)"
 //      Label left "I(q) (cm\\S-1\\M)"
-//
-//End     // end macro 
+//      
+//      SetDataFolder root:
+//End
+
+
+
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function LamellarPS(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("LamellarPSX")
+        yw = LamellarPSX(cw,xw)
+#else
+        yw = fLamellarPS(cw,xw)
+#endif
+        return(0)
+End
 
 // instrument resolution IS included here in S(Q)
-Function LamellarPS(w,x) : FitFunc
+Function fLamellarPS(w,x) : FitFunc
         Wave w
         Variable x
@@ -191 +211 @@
         Return (inten+bkg)
 End
-        
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+//Function fLamellarPS_Smeared(coefW,yW,xW)
+//      Wave coefW,yW,xW
+//      
+//      String str = getWavesDataFolder(yW,0)
+//      String DF="root:"+str+":"
+//      
+//      WAVE resW = $(DF+str+"_res")
+//      
+//      STRUCT ResSmearAAOStruct fs
+//      WAVE fs.coefW = coefW   
+//      WAVE fs.yW = yW
+//      WAVE fs.xW = xW
+//      WAVE fs.resW = resW
+//      
+//      Variable err
+//      err = LamellarPS_Smeared(fs)
+//      
+//      return (0)
+//End
+
 //the smeared model calculation
-//Function LamellarPS_Smeared(w,x) :FitFunc
-//      Wave w
-//      Variable x
-//      
-//      Variable ans
-//      SVAR sq = gSig_Q
-//      SVAR qb = gQ_bar
-//      SVAR sh = gShadow
-//      SVAR gQ = gQVals
-//      
-//      ans = Smear_Model_20(LamellarPS,$sq,$qb,$sh,$gQ,w,x)    
-//
-//      return(ans)
+//Function LamellarPS_Smeared(s) :FitFunc
+//      Struct ResSmearAAOStruct &s
+//
+////    the name of your unsmeared model (AAO) is the first argument
+//      s.yW = Smear_Model_20(LamellarPS,s.coefW,s.xW,s.resW)
+//
+//      return(0)
 //End
-//
+////

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/LamellarPS_HG.ipf

@@ -63 +63 @@
         Edit parameters_LamellarPS_HG, coef_LamellarPS_HG
         ModifyTable width(parameters_LamellarPS_HG)=160
-        ywave_LamellarPS_HG  := LamellarPS_HG(coef_LamellarPS_HG, xwave_LamellarPS_HG)
+        
+        Variable/G root:g_LamellarPS_HS
+        g_LamellarPS_HG := LamellarPS_HG(coef_LamellarPS_HG, ywave_LamellarPS_HG,xwave_LamellarPS_HG)
         Display ywave_LamellarPS_HG vs xwave_LamellarPS_HG
         ModifyGraph marker=29, msize=2, mode=4
@@ -77 +79 @@
 End
 
-//
-//this macro sets up all the necessary parameters and waves that are
-//needed to calculate the  smeared model function.
-//
-//no input parameters are necessary, it MUST use the experimental q-values
-// from the experimental data read in from an AVE/QSIG data file
-////////////////////////////////////////////////////
-//Proc PlotSmeared_LamellarPS_HG()                                                              //Lamellar
-//
-//      // if no gQvals wave, data must not have been loaded => abort
-//      If(ResolutionWavesMissing())            //part of GaussUtils
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+//Proc PlotSmeared_LamellarPS_HG(str)                                                           
+//      String str
+//      Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+//      
+//      // if any of the resolution waves are missing => abort
+//      if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
 //              Abort
 //      endif
+//      
+//      SetDataFolder $("root:"+str)
 //      
 //      // constants
@@ -101 +101 @@
 //      // output smeared intensity wave, dimensions are identical to experimental QSIG values
 //      // make extra copy of experimental q-values for easy plotting
-//      Duplicate/O $gQvals smeared_LamellarPS_HG,smeared_qvals                         //
+//      Duplicate/O $(str+"_q") smeared_LamellarPS_HG,smeared_qvals                             //
 //      SetScale d,0,0,"1/cm",smeared_LamellarPS_HG                                                     //
-//
-//      smeared_LamellarPS_HG := LamellarPS_HG_Smeared(smear_coef_LamellarPS_HG,$gQvals)                // SMEARED function name
-//      Display smeared_LamellarPS_HG vs $gQvals                                                                        //
+//                                      
+//      Variable/G gs_LamellarPS_HG     =0
+//      gs_LamellarPS_HG         := fLamellarPS_HG_Smeared(smear_coef_LamellarPS_HG     ,smeared_LamellarPS_HG  ,smeared_qvals) //this wrapper fills the STRUCT
+//      
+//      Display smeared_LamellarPS_HG vs smeared_qvals                                                          //
 //      ModifyGraph log=1,marker=29,msize=2,mode=4
 //      Label bottom "q (\\S-1\\M)"
 //      Label left "I(q) (cm\\S-1\\M)"
-//
-//End     // end macro 
-
-
-//
-Function LamellarPS_HG(w,x) : FitFunc
+//      
+//      SetDataFolder root:
+//End
+        
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function LamellarPS_HG(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("LamellarPS_HGX")
+        yw = LamellarPS_HGX(cw,xw)
+#else
+        yw = fLamellarPS_HG(cw,xw)
+#endif
+        return(0)
+End
+
+//
+Function fLamellarPS_HG(w,x) : FitFunc
         Wave w
         Variable x
@@ -202 +220 @@
 End
 
-////the smeared model calculation
-//Function LamellarPS_HG_Smeared(w,x) :FitFunc
-//      Wave w
-//      Variable x
-//      
-//      Variable ans
-//      SVAR sq = gSig_Q
-//      SVAR qb = gQ_bar
-//      SVAR sh = gShadow
-//      SVAR gQ = gQVals
-//      
-//      ans = Smear_Model_20(LamellarPS_HG,$sq,$qb,$sh,$gQ,w,x) 
-//
-//      return(ans)
-//End   
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+//Function fLamellarPS_HG_Smeared(coefW,yW,xW)
+//      Wave coefW,yW,xW
+//      
+//      String str = getWavesDataFolder(yW,0)
+//      String DF="root:"+str+":"
+//      
+//      WAVE resW = $(DF+str+"_res")
+//      
+//      STRUCT ResSmearAAOStruct fs
+//      WAVE fs.coefW = coefW   
+//      WAVE fs.yW = yW
+//      WAVE fs.xW = xW
+//      WAVE fs.resW = resW
+//      
+//      Variable err
+//      err = LamellarPS_HG_Smeared(fs)
+//      
+//      return (0)
+//End
+
+//////the smeared model calculation
+//Function LamellarPS_HG_Smeared(s) :FitFunc
+//      Struct ResSmearAAOStruct &s
+//
+////    the name of your unsmeared model (AAO) is the first argument
+//      s.yW = Smear_Model_20(LamellarPS_HG,s.coefW,s.xW,s.resW)
+//
+//      return(0)
+//End
+        

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/LogNormSpheres_and_Struct.ipf

@@ -23 +23 @@
         make/O/T parameters_lns_HS = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","bkg (cm-1 sr-1)"}
         Edit parameters_lns_HS,coef_lns_HS
-        ywave_lns_HS := LogNormalSphere_HS(coef_lns_HS,xwave_lns_HS)
+        
+        Variable/G root:g_lns_HS
+        g_lns_HS := LogNormalSphere_HS(coef_lns_HS,ywave_lns_HS,xwave_lns_HS)
         Display ywave_lns_HS vs xwave_lns_HS
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -31 +33 @@
 End
 
-Proc PlotSmearedLogNormalSphere_HS()                                                            
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedLogNormalSphere_HS(str)                                                         
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -47 +52 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_lns_HS,smeared_qvals                                
+        Duplicate/O $(str+"_q") smeared_lns_HS,smeared_qvals                            
         SetScale d,0,0,"1/cm",smeared_lns_HS                                                    
-
-        smeared_lns_HS := SmearedLogNormalSphere_HS(smear_coef_lns_HS,$gQvals)          
+                                        
+        Variable/G gs_lns_HS=0
+        gs_lns_HS := fSmearedLogNormalSphere_HS(smear_coef_lns_HS,smeared_lns_HS,smeared_qvals) //this wrapper fills the STRUCT
+        
         Display smeared_lns_HS vs smeared_qvals                                                                 
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -56 +63 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function LogNormalSphere_HS(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+        
+
+Function LogNormalSphere_HS(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -88 +97 @@
         
         //calculate each and combine
-        inten = LogNormalPolySphere(form_lns_HS,x)
-        inten *= HardSphereStruct(struct_lns_HS,x)
-        inten *= w[0]
-        inten += w[5]
+        Duplicate/O xw tmp_lns_HS_PQ,tmp_lns_HS_SQ
+        LogNormalPolySphere(form_lns_HS,tmp_lns_HS_PQ,xw)
+        HardSphereStruct(struct_lns_HS,tmp_lns_HS_SQ,xw)
+        yw = tmp_lns_HS_PQ *tmp_lns_HS_SQ
+        yw *= w[0]
+        yw += w[5]
         
         //cleanup waves
 //      Killwaves/Z form_lns_HS,struct_lns_HS
         
-        return (inten)
+        return (0)
 End
 
@@ -111 +122 @@
         make/O/T parameters_lns_SW = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","well depth (kT)","well width (diam.)","bkg (cm-1 sr-1)"}
         Edit parameters_lns_SW,coef_lns_SW
-        ywave_lns_SW := LogNormalSphere_SW(coef_lns_SW,xwave_lns_SW)
+        
+        Variable/G root:g_lns_SW
+        g_lns_SW := LogNormalSphere_SW(coef_lns_SW,ywave_lns_SW,xwave_lns_SW)
         Display ywave_lns_SW vs xwave_lns_SW
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -119 +132 @@
 End
 
-Proc PlotSmearedLogNormalSphere_SW()                                                            
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedLogNormalSphere_SW(str)                                                         
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -135 +151 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_lns_SW,smeared_qvals                                
+        Duplicate/O $(str+"_q") smeared_lns_SW,smeared_qvals                            
         SetScale d,0,0,"1/cm",smeared_lns_SW                                                    
-
-        smeared_lns_SW := SmearedLogNormalSphere_SW(smear_coef_lns_SW,$gQvals)          
+                                        
+        Variable/G gs_lns_SW=0
+        gs_lns_SW := fSmearedLogNormalSphere_SW(smear_coef_lns_SW,smeared_lns_SW,smeared_qvals) //this wrapper fills the STRUCT
+        
         Display smeared_lns_SW vs smeared_qvals                                                                 
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -144 +162 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function LogNormalSphere_SW(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+        
+
+Function LogNormalSphere_SW(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -177 +197 @@
         
         //calculate each and combine
-        inten = LogNormalPolySphere(form_lns_SW,x)
-        inten *= SquareWellStruct(struct_lns_SW,x)
-        inten *= w[0]
-        inten += w[7]
+        Duplicate/O xw tmp_lns_SW_PQ,tmp_lns_SW_SQ
+        LogNormalPolySphere(form_lns_SW,tmp_lns_SW_PQ,xw)
+        SquareWellStruct(struct_lns_SW,tmp_lns_SW_SQ,xw)
+        yw = tmp_lns_SW_PQ * tmp_lns_SW_SQ
+        yw *= w[0]
+        yw += w[7]
         
         //cleanup waves
 //      Killwaves/Z form_lns_SW,struct_lns_SW
         
-        return (inten)
+        return (0)
 End
 
@@ -208 +230 @@
         make/O/T parameters_lns_SC = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","charge","movalent salt(M)","Temperature (K)","dielectric const","bkg (cm-1 sr-1)"}
         Edit parameters_lns_SC,coef_lns_SC
-        ywave_lns_SC := LogNormalSphere_SC(coef_lns_SC,xwave_lns_SC)
+        
+        Variable/G root:g_lns_SC
+        g_lns_SC := LogNormalSphere_SC(coef_lns_SC,ywave_lns_SC,xwave_lns_SC)
         Display ywave_lns_SC vs xwave_lns_SC
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -216 +240 @@
 End
 
-Proc PlotSmearedLogNormalSphere_SC()                                                            
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedLogNormalSphere_SC(str)                                                         
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
-
+        
+        SetDataFolder $("root:"+str)
+        
         if (DataFolderExists("root:HayPenMSA"))
                 Make/O/D/N=17 root:HayPenMSA:gMSAWave
@@ -239 +266 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_lns_SC,smeared_qvals                                
+        Duplicate/O $(str+"_q") smeared_lns_SC,smeared_qvals                            
         SetScale d,0,0,"1/cm",smeared_lns_SC                                                    
-
-        smeared_lns_SC := SmearedLogNormalSphere_SC(smear_coef_lns_SC,$gQvals)          
+                                        
+        Variable/G gs_lns_SC=0
+        gs_lns_SC := fSmearedLogNormalSphere_SC(smear_coef_lns_SC,smeared_lns_SC,smeared_qvals) //this wrapper fills the STRUCT
+        
         Display smeared_lns_SC vs smeared_qvals                                                                 
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -248 +277 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function LogNormalSphere_SC(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+
+
+
+Function LogNormalSphere_SC(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -283 +315 @@
         
         //calculate each and combine
-        inten = LogNormalPolySphere(form_lns_SC,x)
-        inten *= HayterPenfoldMSA(struct_lns_SC,x)
-        inten *= w[0]
-        inten += w[9]
+        Duplicate/O xw tmp_lns_SC_PQ,tmp_lns_SC_SQ
+        LogNormalPolySphere(form_lns_SC,tmp_lns_SC_PQ,xw)
+        HayterPenfoldMSA(struct_lns_SC,tmp_lns_SC_SQ,xw)
+        yw = tmp_lns_SC_PQ * tmp_lns_SC_SQ
+        yw *= w[0]
+        yw += w[9]
         
         //cleanup waves
 //      Killwaves/Z form_lns_SC,struct_lns_SC
         
-        return (inten)
+        return (0)
 End
 
@@ -306 +340 @@
         make/O/T parameters_lns_SHS = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","perturbation parameter (0.1)","stickiness, tau","bkg (cm-1 sr-1)"}
         Edit parameters_lns_SHS,coef_lns_SHS
-        ywave_lns_SHS := LogNormalSphere_SHS(coef_lns_SHS,xwave_lns_SHS)
+        
+        Variable/G root:g_lns_SHS
+        g_lns_SHS := LogNormalSphere_SHS(coef_lns_SHS,ywave_lns_SHS,xwave_lns_SHS)
         Display ywave_lns_SHS vs xwave_lns_SHS
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -314 +350 @@
 End
 
-Proc PlotSmearedLogNormalSphere_SHS()                                                           
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedLogNormalSphere_SHS(str)                                                                
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -330 +369 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_lns_SHS,smeared_qvals                               
+        Duplicate/O $(str+"_q") smeared_lns_SHS,smeared_qvals                           
         SetScale d,0,0,"1/cm",smeared_lns_SHS                                                   
-
-        smeared_lns_SHS := SmearedLogNormalSphere_SHS(smear_coef_lns_SHS,$gQvals)               
+                                        
+        Variable/G gs_lns_SHS=0
+        gs_lns_SHS := fSmearedLogNormalSphere_SHS(smear_coef_lns_SHS,smeared_lns_SHS,smeared_qvals)     //this wrapper fills the STRUCT
+        
         Display smeared_lns_SHS vs smeared_qvals                                                                        
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -339 +380 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function LogNormalSphere_SHS(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+        
+
+Function LogNormalSphere_SHS(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -372 +415 @@
         
         //calculate each and combine
-        inten = LogNormalPolySphere(form_lns_SHS,x)
-        inten *= StickyHS_Struct(struct_lns_SHS,x)
-        inten *= w[0]
-        inten += w[7]
+        Duplicate/O xw tmp_lns_SHS_PQ,tmp_lns_SHS_SQ
+        LogNormalPolySphere(form_lns_SHS,tmp_lns_SHS_PQ,xw)
+        StickyHS_Struct(struct_lns_SHS,tmp_lns_SHS_SQ,xw)
+        yw = tmp_lns_SHS_PQ * tmp_lns_SHS_SQ
+        yw *= w[0]
+        yw += w[7]
         
         //cleanup waves
 //      Killwaves/Z form_lns_SHS,struct_lns_SHS
         
-        return (inten)
+        return (0)
 End
 
 
 // this is all there is to the smeared calculation!
-Function SmearedLogNormalSphere_HS(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(LogNormalSphere_HS,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+Function SmearedLogNormalSphere_HS(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(LogNormalSphere_HS,s.coefW,s.xW,s.resW)
+
+        return(0)
 End
 
 // this is all there is to the smeared calculation!
-Function SmearedLogNormalSphere_SW(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(LogNormalSphere_SW,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+Function SmearedLogNormalSphere_SW(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(LogNormalSphere_SW,s.coefW,s.xW,s.resW)
+
+        return(0)
 End
 
 // this is all there is to the smeared calculation!
-Function SmearedLogNormalSphere_SC(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(LogNormalSphere_SC,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+Function SmearedLogNormalSphere_SC(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(LogNormalSphere_SC,s.coefW,s.xW,s.resW)
+
+        return(0)
 End
 
 // this is all there is to the smeared calculation!
-Function SmearedLogNormalSphere_SHS(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(LogNormalSphere_SHS,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
+Function SmearedLogNormalSphere_SHS(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(LogNormalSphere_SHS,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedLogNormalSphere_HS(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedLogNormalSphere_HS(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedLogNormalSphere_SW(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedLogNormalSphere_SW(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedLogNormalSphere_SC(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedLogNormalSphere_SC(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedLogNormalSphere_SHS(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedLogNormalSphere_SHS(fs)
+        
+        return (0)
+End
+

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/LogNormalSphere.ipf

@@ -19 +19 @@
         make/O/T parameters_lns = {"Volume Fraction (scale)","exp(mu)=median Radius (A)","sigma","SLD sphere (A-2)","SLD solvent (A-2)","bkg (cm-1 sr-1)"}
         Edit parameters_lns,coef_lns
-        ywave_lns := LogNormalPolySphere(coef_lns,xwave_lns)
+        
+        Variable/G root:g_lns
+        g_lns := LogNormalPolySphere(coef_lns,ywave_lns,xwave_lns)
         Display ywave_lns vs xwave_lns
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -27 +29 @@
 End
 
-Proc PlotSmearLogNormPolySphere()                                                               
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearLogNormPolySphere(str)                                                            
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -43 +48 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_lns,smeared_qvals                           
+        Duplicate/O $(str+"_q") smeared_lns,smeared_qvals                               
         SetScale d,0,0,"1/cm",smeared_lns                                                       
-
-        smeared_lns := SmearLogNormSphere(smear_coef_lns,$gQvals)               
+                                        
+        Variable/G gs_lns=0
+        gs_lns := fSmearLogNormSphere(smear_coef_lns,smeared_lns,smeared_qvals) //this wrapper fills the STRUCT
+        
         Display smeared_lns vs smeared_qvals                                                                    
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -52 +59 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
+        
+        SetDataFolder root:
+End
+
+
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function LogNormalPolySphere(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("LogNormalPolySphereX")
+        yw = LogNormalPolySphereX(cw,xw)
+#else
+        yw = fLogNormalPolySphere(cw,xw)
+#endif
+        return(0)
 End
 
@@ -59 +85 @@
 // 76 points is slower, but reccommended to remove high-q oscillations
 //
-Function LogNormalPolySphere(w,x): FitFunc
+Function fLogNormalPolySphere(w,x): FitFunc
         wave w
         variable x
@@ -127 +153 @@
         
         summ = 0.0              // initialize integral
+        Make/O/N=1 tmp_w
         for(ii=0;ii<nord;ii+=1)
                 // calculate Gauss points on integration interval (r-value for evaluation)
@@ -132 +159 @@
                 sphere_temp[1] = zi
                 // calculate sphere scattering
-                yy = gauWt[ii] *  LogNormal_distr(sig,mu,zi) * SphereForm(sphere_temp,x)
+                SphereForm(sphere_temp,tmp_w,x)                 //AAO calculation, one point wave
+                yy = gauWt[ii] *  LogNormal_distr(sig,mu,zi) * tmp_w[0]
                 yy *= 4*pi/3*zi*zi*zi           //un-normalize by current sphere volume
                 
@@ -151 +179 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearLogNormSphere(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearLogNormSphere(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearLogNormSphere(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(LogNormalPolySphere,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
+Function SmearLogNormSphere(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(LogNormalPolySphere,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+        
+
 
 // normalization is correct, using 3rd moment of lognormal distribution

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/MultiShell.ipf

@@ -22 +22 @@
         make/O/T parameters_mss = {"scale","core radius (A)","shell thickness (A)","water thickness","core & solvent SLD (A-2)","Shell SLD (A-2)","number of water/shell pairs","bkg (cm-1)"}
         Edit/K=1 parameters_mss,coef_mss
-        ywave_mss := MultiShellForm(coef_mss,xwave_mss)
+        
+        Variable/G root:g_mss
+        g_mss := MultiShellForm(coef_mss,ywave_mss,xwave_mss)
         Display/K=1 ywave_mss vs xwave_mss
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -30 +32 @@
 End
 
-Proc PlotSmearedMultiShell()                                                            
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedMultiShell(str)                                                         
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
         
-        // if no gQvals wave, data must not have been loaded => abort
-        if(Exists("gQvals") != 2)               // 2 = string or numeric variable exists
-                Abort "6-column QSIG data not loaded. Use LoadQSIGData macro"
-        else
-                if(WaveExists($gQvals) ==0)     //wave ref does not exist
-                        Abort "6-column QSIG waves are missing. Re-load with LoadQSIGData macro"
-                endif
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
+                Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -50 +51 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_mss,smeared_qvals                           
+        Duplicate/O $(str+"_q") smeared_mss,smeared_qvals                               
         SetScale d,0,0,"1/cm",smeared_mss                                                       
-
-        smeared_mss := SmearedMultiShell(smear_coef_mss,$gQvals)                
+                                        
+        Variable/G gs_mss=0
+        gs_mss := fSmearedMultiShell(smear_coef_mss,smeared_mss,smeared_qvals)  //this wrapper fills the STRUCT
+        
         Display/K=1 smeared_mss vs smeared_qvals                                                                        
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -59 +62 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
+        
+        SetDataFolder root:
 End
 
-Function MultiShellForm(w,x) :FitFunc
+
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function MultiShellForm(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("MultiShellFormX")
+        yw = MultiShellFormX(cw,xw)
+#else
+        yw = fMultiShellForm(cw,xw)
+#endif
+        return(0)
+End
+
+Function fMultiShellForm(w,x) :FitFunc
         Wave w
         Variable x
@@ -136 +158 @@
 //End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedMultiShell(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedMultiShell(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearedMultiShell(w,x) :FitFunc
-        Wave w
-        Variable x
+Function SmearedMultiShell(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(MultiShellForm,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
         
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_76(MultiShellForm,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/Parallelepiped.ipf

@@ -38 +38 @@
         make/o/t parameters_Parallelepiped = {"Scale Factor","Shortest Edge A ()","B ()","Longest Edge C ()","Contrast (^-2)","Incoherent Bgd (cm-1)"}      //CH#3
         Edit parameters_Parallelepiped, coef_Parallelepiped
-        ywave_Parallelepiped  := Parallelepiped(coef_Parallelepiped, xwave_Parallelepiped)
+        
+        Variable/G root:g_Parallelepiped
+        g_Parallelepiped := Parallelepiped(coef_Parallelepiped,ywave_Parallelepiped, xwave_Parallelepiped)
         Display ywave_Parallelepiped vs xwave_Parallelepiped
         ModifyGraph marker=29, msize=2, mode=4
@@ -48 +50 @@
 End
 
-//
-//this macro sets up all the necessary parameters and waves that are
-//needed to calculate the  smeared model function.
-//
-//no input parameters are necessary, it MUST use the experimental q-values
-// from the experimental data read in from an AVE/QSIG data file
-////////////////////////////////////////////////////
-Proc PlotSmeared_Parallelepiped()                                                               //Parallelepiped
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmeared_Parallelepiped(str)                                                            
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
         
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -69 +69 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_Parallelepiped,smeared_qvals                                //
+        Duplicate/O $(str+"_q") smeared_Parallelepiped,smeared_qvals                            //
         SetScale d,0,0,"1/cm",smeared_Parallelepiped                                                    //
-
-        smeared_Parallelepiped := Parallelepiped_Smeared(smear_coef_Parallelepiped,$gQvals)             // SMEARED function name
+                                        
+        Variable/G gs_Parallelepiped=0
+        gs_Parallelepiped := fParallelepiped_Smeared(smear_coef_Parallelepiped,smeared_Parallelepiped,smeared_qvals)    //this wrapper fills the STRUCT
+        
         Display smeared_Parallelepiped vs smeared_qvals                                                                 //
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -78 +80 @@
         Label left "I(q) (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End     // end macro 
+        
+        SetDataFolder root:
+End
+
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function Parallelepiped(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("ParallelepipedX")
+        yw = ParallelepipedX(cw,xw)
+#else
+        yw = fParallelepiped(cw,xw)
+#endif
+        return(0)
+End
 
 // calculates the form factor of a rectangular solid
 // - a double integral - choose points wisely
 //
-Function Parallelepiped(w,x) : FitFunc
+Function fParallelepiped(w,x) : FitFunc
         Wave w
         Variable x
@@ -178 +198 @@
 End
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fParallelepiped_Smeared(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = Parallelepiped_Smeared(fs)
+        
+        return (0)
+End
 
 // this is all there is to the smeared calculation!
-Function Parallelepiped_Smeared(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(Parallelepiped,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
+Function Parallelepiped_Smeared(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(Parallelepiped,s.coefW,s.xW,s.resW)
+
+        return(0)
+End

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/PolyCoreShellCylinder.ipf

@@ -33 +33 @@
         ModifyTable width(parameters_CSCpr)=162
         
-        ywave_CSCpr:= PolyCoShCylinder(coef_CSCpr,xwave_CSCpr)
+        Variable/G root:g_CSCpr
+        g_CSCpr := PolyCoShCylinder(coef_CSCpr,ywave_CSCpr,xwave_CSCpr)
         Display ywave_CSCpr vs xwave_CSCpr
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -41 +42 @@
 End
 
-
-Proc PlotSmearedPolyCoShCylinder()                                                      
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedPolyCoShCylinder(str)                                                           
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -59 +62 @@
         // make extra copy of experimental q-values for easy plotting
         
-        Duplicate/O $gQvals smeared_CSCpr,smeared_qvals                         
+        Duplicate/O $(str+"_q") smeared_CSCpr,smeared_qvals                             
         SetScale d,0,0,"1/cm",smeared_CSCpr                                                     
-
-        smeared_CSCpr := SmearedPolyCoShCylinder(smear_coef_CSCpr,$gQvals)              
+                                        
+        Variable/G gs_CSCpr=0
+        gs_CSCpr := fSmearedPolyCoShCylinder(smear_coef_CSCpr,smeared_CSCpr,smeared_qvals)      //this wrapper fills the STRUCT
+        
         Display smeared_CSCpr vs smeared_qvals                                                                  
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -68 +73 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
+        
+        SetDataFolder root:
+End
+        
+
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function PolyCoShCylinder(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("PolyCoShCylinderX")
+        yw = PolyCoShCylinderX(cw,xw)
+#else
+        yw = fPolyCoShCylinder(cw,xw)
+#endif
+        return(0)
 End
 
@@ -75 +98 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-Function PolyCoShCylinder(w,x) : FitFunc
+Function fPolyCoShCylinder(w,x) : FitFunc
         Wave w
         Variable x
@@ -278 +301 @@
 End     //Function CScyl()
 
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedPolyCoShCylinder(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedPolyCoShCylinder(fs)
+        
+        return (0)
+End
+
 // this is all there is to the smeared calculation!
-Function SmearedPolyCoShCylinder(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(PolyCoShCylinder,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
-
-
+Function SmearedPolyCoShCylinder(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(PolyCoShCylinder,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+        

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/SchulzSpheres.ipf

@@ -20 +20 @@
         make/O/T parameters_sch = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","bkg (cm-1 sr-1)"}
         Edit parameters_sch,coef_sch
-        ywave_sch := SchulzSpheres(coef_sch,xwave_sch)
+        
+        Variable/G root:g_sch
+        g_sch := SchulzSpheres(coef_sch,ywave_sch,xwave_sch)
         Display ywave_sch vs xwave_sch
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -28 +30 @@
 End
 
-Proc PlotSmearedSchulzPolySpheres()                                                             
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedSchulzPolySpheres(str)                                                          
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -44 +50 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_sch,smeared_qvals                           
+        Duplicate/O $(str+"_q") smeared_sch,smeared_qvals                               
         SetScale d,0,0,"1/cm",smeared_sch                                                       
-
-        smeared_sch := SmearedSchulzSpheres(smear_coef_sch,$gQvals)             
+                                        
+        Variable/G gs_sch=0
+        gs_sch := fSmearedSchulzSpheres(smear_coef_sch,smeared_sch,smeared_qvals)       //this wrapper fills the STRUCT
+        
         Display smeared_sch vs smeared_qvals                                                                    
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -53 +61 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
+        
+        SetDataFolder root:
+End
+        
 
 
@@ -65 +76 @@
 End
 
+
+//AAO version, uses XOP if available
+// simply calls the original single point calculation with
+// a wave assignment (this will behave nicely if given point ranges)
+Function SchulzSpheres(cw,yw,xw) : FitFunc
+        Wave cw,yw,xw
+        
+#if exists("SchulzSpheresX")
+        yw = SchulzSpheresX(cw,xw)
+#else
+        yw = fSchulzSpheres(cw,xw)
+#endif
+        return(0)
+End
+
 //use the analytic formula from Kotlarchyk & Chen, JCP 79 (1983) 2461
 //equations 23-30
@@ -70 +96 @@
 // need to calculate in terms of logarithms to avoid numerical errors
 //
-Function SchulzSpheres(w,x) : FitFunc
+Function fSchulzSpheres(w,x) : FitFunc
         Wave w
         Variable x
@@ -159 +185 @@
 End
 
-
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedSchulzSpheres(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedSchulzSpheres(fs)
+        
+        return (0)
+End
 
 // this is all there is to the smeared calculation!
-Function SmearedSchulzSpheres(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(SchulzSpheres,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+Function SmearedSchulzSpheres(s) :FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(SchulzSpheres,s.coefW,s.xW,s.resW)
+
+        return(0)
 End
 

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/SchulzSpheres_and_Struct.ipf

@@ -23 +23 @@
         make/O/T parameters_sch_HS = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","bkg (cm-1 sr-1)"}
         Edit parameters_sch_HS,coef_sch_HS
-        ywave_sch_HS := SchulzSpheres_HS(coef_sch_HS,xwave_sch_HS)
+        
+        Variable/G root:g_sch_HS
+        g_sch_HS := SchulzSpheres_HS(coef_sch_HS,ywave_sch_HS,xwave_sch_HS)
         Display ywave_sch_HS vs xwave_sch_HS
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -31 +33 @@
 End
 
-Proc PlotSmearedSchulzSpheres_HS()                                                              
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedSchulzSpheres_HS(str)                                                           
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -47 +52 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_sch_HS,smeared_qvals                                
+        Duplicate/O $(str+"_q") smeared_sch_HS,smeared_qvals                            
         SetScale d,0,0,"1/cm",smeared_sch_HS                                                    
-
-        smeared_sch_HS := SmearedSchulzSpheres_HS(smear_coef_sch_HS,$gQvals)            
+                                        
+        Variable/G gs_sch_HS=0
+        gs_sch_HS := fSmearedSchulzSpheres_HS(smear_coef_sch_HS,smeared_sch_HS,smeared_qvals)   //this wrapper fills the STRUCT
+        
         Display smeared_sch_HS vs smeared_qvals                                                                 
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -56 +63 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function SchulzSpheres_HS(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+        
+
+
+Function SchulzSpheres_HS(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -89 +99 @@
         
         //calculate each and combine
-        inten = SchulzSpheres(form_sch_HS,x)
-        inten *= HardSphereStruct(struct_sch_HS,x)
-        inten *= w[0]
-        inten += w[5]
+        Duplicate/O xw tmp_sch_HS_PQ,tmp_sch_HS_SQ
+        SchulzSpheres(form_sch_HS,tmp_sch_HS_PQ,xw)
+        HardSphereStruct(struct_sch_HS,tmp_sch_HS_SQ,xw)
+        yw = tmp_sch_HS_PQ * tmp_sch_HS_SQ
+        yw *= w[0]
+        yw += w[5]
         
         //cleanup waves
 //      Killwaves/Z form_sch_HS,struct_sch_HS
         
-        return (inten)
+        return (0)
 End
 
@@ -112 +124 @@
         make/O/T parameters_sch_SW = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","well depth (kT)","well width (diam.)","bkg (cm-1 sr-1)"}
         Edit parameters_sch_SW,coef_sch_SW
-        ywave_sch_SW := SchulzSpheres_SW(coef_sch_SW,xwave_sch_SW)
+
+        Variable/G root:g_sch_SW
+        g_sch_SW := SchulzSpheres_SW(coef_sch_SW,ywave_sch_SW,xwave_sch_SW)
         Display ywave_sch_SW vs xwave_sch_SW
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -120 +134 @@
 End
 
-Proc PlotSmearedSchulzSpheres_SW()                                                              
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedSchulzSpheres_SW(str)                                                           
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -136 +153 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_sch_SW,smeared_qvals                                
+        Duplicate/O $(str+"_q") smeared_sch_SW,smeared_qvals                            
         SetScale d,0,0,"1/cm",smeared_sch_SW                                                    
-
-        smeared_sch_SW := SmearedSchulzSpheres_SW(smear_coef_sch_SW,$gQvals)            
+                                        
+        Variable/G gs_sch_SW=0
+        gs_sch_SW := fSmearedSchulzSpheres_SW(smear_coef_sch_SW,smeared_sch_SW,smeared_qvals)   //this wrapper fills the STRUCT
+        
         Display smeared_sch_SW vs smeared_qvals                                                                 
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -145 +164 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function SchulzSpheres_SW(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+
+        
+
+Function SchulzSpheres_SW(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -179 +201 @@
         
         //calculate each and combine
-        inten = SchulzSpheres(form_sch_SW,x)
-        inten *= SquareWellStruct(struct_sch_SW,x)
-        inten *= w[0]
-        inten += w[7]
+        Duplicate/O xw tmp_sch_SW_PQ,tmp_sch_SW_SQ
+        SchulzSpheres(form_sch_SW,tmp_sch_SW_PQ,xw)
+        SquareWellStruct(struct_sch_SW,tmp_sch_SW_SQ,xw)
+        yw = tmp_sch_SW_PQ * tmp_sch_SW_SQ
+        yw *= w[0]
+        yw += w[7]
         
         //cleanup waves
 //      Killwaves/Z form_sch_SW,struct_sch_SW
         
-        return (inten)
+        return (0)
 End
 
@@ -210 +234 @@
         make/O/T parameters_sch_SC = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","charge","movalent salt(M)","Temperature (K)","dielectric const","bkg (cm-1 sr-1)"}
         Edit parameters_sch_SC,coef_sch_SC
-        ywave_sch_SC := SchulzSpheres_SC(coef_sch_SC,xwave_sch_SC)
+        
+        Variable/G root:g_sch_SC
+        g_sch_SC := SchulzSpheres_SC(coef_sch_SC,ywave_sch_SC,xwave_sch_SC)
         Display ywave_sch_SC vs xwave_sch_SC
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -218 +244 @@
 End
 
-Proc PlotSmearedSchulzSpheres_SC()                                                              
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedSchulzSpheres_SC(str)                                                           
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
-
+        
+        SetDataFolder $("root:"+str)
+        
         if (DataFolderExists("root:HayPenMSA"))
                 Make/O/D/N=17 root:HayPenMSA:gMSAWave
@@ -241 +270 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_sch_SC,smeared_qvals                                
+        Duplicate/O $(str+"_q") smeared_sch_SC,smeared_qvals                            
         SetScale d,0,0,"1/cm",smeared_sch_SC                                                    
-
-        smeared_sch_SC := SmearedSchulzSpheres_SC(smear_coef_sch_SC,$gQvals)            
+                                        
+        Variable/G gs_sch_SC=0
+        gs_sch_SC := fSmearedSchulzSpheres_SC(smear_coef_sch_SC,smeared_sch_SC,smeared_qvals)   //this wrapper fills the STRUCT
+        
         Display smeared_sch_SC vs smeared_qvals                                                                 
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -250 +281 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function SchulzSpheres_SC(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+
+
+Function SchulzSpheres_SC(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -286 +319 @@
         
         //calculate each and combine
-        inten = SchulzSpheres(form_sch_SC,x)
-        inten *= HayterPenfoldMSA(struct_sch_SC,x)
-        inten *= w[0]
-        inten += w[9]
+        Duplicate/O xw tmp_sch_SC_PQ,tmp_sch_SC_SQ
+        SchulzSpheres(form_sch_SC,tmp_sch_SC_PQ,xw)
+        HayterPenfoldMSA(struct_sch_SC,tmp_sch_SC_SQ,xw)
+        yw = tmp_sch_SC_PQ *tmp_sch_SC_SQ
+        yw *= w[0]
+        yw += w[9]
         
         //cleanup waves
 //      Killwaves/Z form_sch_SC,struct_sch_SC
         
-        return (inten)
+        return (0)
 End
 
@@ -309 +344 @@
         make/O/T parameters_sch_SHS = {"Volume Fraction (scale)","mean radius (A)","polydisp (sig/avg)","SLD sphere (A-2)","SLD solvent (A-2)","perturbation parameter (0.1)","stickiness, tau","bkg (cm-1 sr-1)"}
         Edit parameters_sch_SHS,coef_sch_SHS
-        ywave_sch_SHS := SchulzSpheres_SHS(coef_sch_SHS,xwave_sch_SHS)
+        
+        Variable/G root:g_sch_SHS
+        g_sch_SHS := SchulzSpheres_SHS(coef_sch_SHS,ywave_sch_SHS,xwave_sch_SHS)
         Display ywave_sch_SHS vs xwave_sch_SHS
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -317 +354 @@
 End
 
-Proc PlotSmearedSchulzSpheres_SHS()                                                             
-        //no input parameters necessary, it MUST use the experimental q-values
-        // from the experimental data read in from an AVE/QSIG data file
-        
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmearedSchulzSpheres_SHS(str)                                                          
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -333 +373 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_sch_SHS,smeared_qvals                               
+        Duplicate/O $(str+"_q") smeared_sch_SHS,smeared_qvals                           
         SetScale d,0,0,"1/cm",smeared_sch_SHS                                                   
-
-        smeared_sch_SHS := SmearedSchulzSpheres_SHS(smear_coef_sch_SHS,$gQvals)         
+                                        
+        Variable/G gs_sch_SHS=0
+        gs_sch_SHS := fSmearedSchulzSpheres_SHS(smear_coef_sch_SHS,smeared_sch_SHS,smeared_qvals)       //this wrapper fills the STRUCT
+        
         Display smeared_sch_SHS vs smeared_qvals                                                                        
         ModifyGraph log=1,marker=29,msize=2,mode=4
@@ -342 +384 @@
         Label left "Intensity (cm\\S-1\\M)"
         AutoPositionWindow/M=1/R=$(WinName(0,1)) $WinName(0,2)
-End
-
-Function SchulzSpheres_SHS(w,x) : FitFunc
-        Wave w
-        Variable x
+        
+        SetDataFolder root:
+End
+
+
+Function SchulzSpheres_SHS(w,yw,xw) : FitFunc
+        Wave w,yw,xw
         
         Variable inten
@@ -376 +420 @@
         
         //calculate each and combine
-        inten = SchulzSpheres(form_sch_SHS,x)
-        inten *= StickyHS_Struct(struct_sch_SHS,x)
-        inten *= w[0]
-        inten += w[7]
+        Duplicate/O xw tmp_sch_SHS_PQ,tmp_sch_SHS_SQ
+        SchulzSpheres(form_sch_SHS,tmp_sch_SHS_PQ,xw)
+        StickyHS_Struct(struct_sch_SHS,tmp_sch_SHS_PQ,xw)
+        yw = tmp_sch_SHS_PQ * tmp_sch_SHS_SQ
+        yw *= w[0]
+        yw += w[7]
         
         //cleanup waves
 //      Killwaves/Z form_sch_SHS,struct_sch_SHS
         
-        return (inten)
+        return (0)
 End
 
@@ -390 +436 @@
 
 // this is all there is to the smeared calculation!
-Function SmearedSchulzSpheres_HS(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(SchulzSpheres_HS,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+Function SmearedSchulzSpheres_HS(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(SchulzSpheres_HS,s.coefW,s.xW,s.resW)
+
+        return(0)
 End
 
 // this is all there is to the smeared calculation!
-Function SmearedSchulzSpheres_SW(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(SchulzSpheres_SW,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+Function SmearedSchulzSpheres_SW(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(SchulzSpheres_SW,s.coefW,s.xW,s.resW)
+
+        return(0)
 End
 
 // this is all there is to the smeared calculation!
-Function SmearedSchulzSpheres_SC(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(SchulzSpheres_SC,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
+Function SmearedSchulzSpheres_SC(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(SchulzSpheres_SC,s.coefW,s.xW,s.resW)
+
+        return(0)
 End
 
 // this is all there is to the smeared calculation!
-Function SmearedSchulzSpheres_SHS(w,x) :FitFunc
-        Wave w
-        Variable x
-        
-        Variable ans
-        SVAR sq = gSig_Q
-        SVAR qb = gQ_bar
-        SVAR sh = gShadow
-        SVAR gQ = gQVals
-        
-        //the name of your unsmeared model is the first argument
-        ans = Smear_Model_20(SchulzSpheres_SHS,$sq,$qb,$sh,$gQ,w,x)
-
-        return(ans)
-End
+Function SmearedSchulzSpheres_SHS(s) : FitFunc
+        Struct ResSmearAAOStruct &s
+
+//      the name of your unsmeared model (AAO) is the first argument
+        s.yW = Smear_Model_20(SchulzSpheres_SHS,s.coefW,s.xW,s.resW)
+
+        return(0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedSchulzSpheres_HS(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedSchulzSpheres_HS(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedSchulzSpheres_SW(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedSchulzSpheres_SW(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedSchulzSpheres_SC(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedSchulzSpheres_SC(fs)
+        
+        return (0)
+End
+
+//wrapper to calculate the smeared model as an AAO-Struct
+// fills the struct and calls the ususal function with the STRUCT parameter
+//
+// used only for the dependency, not for fitting
+//
+Function fSmearedSchulzSpheres_SHS(coefW,yW,xW)
+        Wave coefW,yW,xW
+        
+        String str = getWavesDataFolder(yW,0)
+        String DF="root:"+str+":"
+        
+        WAVE resW = $(DF+str+"_res")
+        
+        STRUCT ResSmearAAOStruct fs
+        WAVE fs.coefW = coefW   
+        WAVE fs.yW = yW
+        WAVE fs.xW = xW
+        WAVE fs.resW = resW
+        
+        Variable err
+        err = SmearedSchulzSpheres_SHS(fs)
+        
+        return (0)
+End
+

sans/Analysis/branches/ajj_23APR07/IGOR_Package_Files/Put in User Procedures/SANS_Models_v3.00/NewModels_2006/TriaxialEllipsoid.ipf

@@ -34 +34 @@
         make/o/t parameters_triax = {"Scale Factor","Semi-axis A [smallest]()","Semi-axis B ()","Semi-axis C [largest]()","Contrast (^-2)","Incoherent Bgd (cm-1)"} //CH#3
         Edit parameters_triax, coef_triax
-        ywave_triax  := TriaxialEllipsoid(coef_triax, xwave_triax)
+        
+        Variable/G root:g_triax
+        g_triax := TriaxialEllipsoid(coef_triax, ywave_triax, xwave_triax)
         Display ywave_triax vs xwave_triax
         ModifyGraph marker=29, msize=2, mode=4
@@ -44 +46 @@
 End
 
-//
-//this Proc sets up all the necessary parameters and waves that are
-//needed to calculate the  smeared model function.
-//
-//no input parameters are necessary, it MUST use the experimental q-values
-// from the experimental data read in from an AVE/QSIG data file
-////////////////////////////////////////////////////
-Proc PlotSmeared_TriAxEllipsoid()                                                               //triax
-        // if no gQvals wave, data must not have been loaded => abort
-        if(ResolutionWavesMissing())
+
+// - sets up a dependency to a wrapper, not the actual SmearedModelFunction
+Proc PlotSmeared_TriAxEllipsoid(str)                                                            
+        String str
+        Prompt str,"Pick the data folder conatining the resolution you want",popup,getAList(4)
+        
+        // if any of the resolution waves are missing => abort
+        if(ResolutionWavesMissingDF(str))               //updated to NOT use global strings (in GaussUtils)
                 Abort
         endif
+        
+        SetDataFolder $("root:"+str)
         
         // Setup parameter table for model function
@@ -64 +66 @@
         // output smeared intensity wave, dimensions are identical to experimental QSIG values
         // make extra copy of experimental q-values for easy plotting
-        Duplicate/O $gQvals smeared_triax,smeared_qvals                         //
+        Duplicate/O $(str+"_q") smeared_triax,smeared_qvals                             //
         SetScale d,0,0,"1/cm",smeared_triax                                                     //
-
-        smeared_triax := Triax_Smeared(smear_coef_triax,$gQvals)                // SMEARED function name
+                                        
+        Variable/G gs_triax=0
+        gs_triax := fTriax_Smeared(smear_coef_triax,smeared_triax,smeared_qvals)        //this wrapper fills the STRUCT
+        
         Display smeared_triax vs smeared_qvals&