Merge pull request #157 from cadenmyers13/fitrecipe-dep

deprecate: Deprecate remaining methods of `FitRecipe`

Author: sbillinge

docs/examples/coreshellnp.py

@@ -89,43 +89,47 @@ def makeRecipe(stru1, stru2, datname):
 
     # Vary the inner radius and thickness of the shell. Constrain the core
     # diameter to twice the shell radius.
-    recipe.addVar(contribution.radius, 15)
-    recipe.addVar(contribution.thickness, 11)
+    recipe.add_variable(contribution.radius, 15)
+    recipe.add_variable(contribution.thickness, 11)
     recipe.constrain(contribution.psize, "2 * radius")
 
     # Configure the fit variables
     # Start by configuring the scale factor and resolution factors.
     # We want the sum of the phase scale factors to be 1.
-    recipe.newVar("scale_CdS", 0.7)
+    recipe.create_new_variable("scale_CdS", 0.7)
     recipe.constrain(generator_cds.scale, "scale_CdS")
     recipe.constrain(generator_zns.scale, "1 - scale_CdS")
     # We also want the resolution factor to be the same on each.
 
     # Vary the global scale as well.
-    recipe.addVar(contribution.scale, 0.3)
+    recipe.add_variable(contribution.scale, 0.3)
 
     # Now we can configure the structural parameters. We tag the different
     # structural variables so we can easily turn them on and off in the
     # subsequent refinement.
     phase_cds = generator_cds.phase
     for par in phase_cds.sgpars.latpars:
-        recipe.addVar(par, name=par.name + "_cds", tag="lat")
+        recipe.add_variable(par, name=par.name + "_cds", tag="lat")
     for par in phase_cds.sgpars.adppars:
-        recipe.addVar(par, 1, name=par.name + "_cds", tag="adp")
-    recipe.addVar(phase_cds.sgpars.xyzpars.z_1, name="z_1_cds", tag="xyz")
+        recipe.add_variable(par, 1, name=par.name + "_cds", tag="adp")
+    recipe.add_variable(
+        phase_cds.sgpars.xyzpars.z_1, name="z_1_cds", tag="xyz"
+    )
     # Since we know these have stacking disorder, constrain the B33 adps for
     # each atom type.
     recipe.constrain("B33_1_cds", "B33_0_cds")
-    recipe.addVar(generator_cds.delta2, name="delta2_cds", value=5)
+    recipe.add_variable(generator_cds.delta2, name="delta2_cds", value=5)
 
     phase_zns = generator_zns.phase
     for par in phase_zns.sgpars.latpars:
-        recipe.addVar(par, name=par.name + "_zns", tag="lat")
+        recipe.add_variable(par, name=par.name + "_zns", tag="lat")
     for par in phase_zns.sgpars.adppars:
-        recipe.addVar(par, 1, name=par.name + "_zns", tag="adp")
-    recipe.addVar(phase_zns.sgpars.xyzpars.z_1, name="z_1_zns", tag="xyz")
+        recipe.add_variable(par, 1, name=par.name + "_zns", tag="adp")
+    recipe.add_variable(
+        phase_zns.sgpars.xyzpars.z_1, name="z_1_zns", tag="xyz"
+    )
     recipe.constrain("B33_1_zns", "B33_0_zns")
-    recipe.addVar(generator_zns.delta2, name="delta2_zns", value=2.5)
+    recipe.add_variable(generator_zns.delta2, name="delta2_zns", value=2.5)
 
     # Give the recipe away so it can be used!
     return recipe

docs/examples/crystalpdf.py

@@ -113,17 +113,17 @@ def makeRecipe(ciffile, datname):
     # the xyzpars, latpars, and adppars members of the SpaceGroupParameters
     # object.
     for par in sgpars.latpars:
-        recipe.addVar(par)
+        recipe.add_variable(par)
     for par in sgpars.adppars:
-        recipe.addVar(par, 0.005)
+        recipe.add_variable(par, 0.005)
 
     # We now select non-structural parameters to refine.
     # This controls the scaling of the PDF.
-    recipe.addVar(generator.scale, 1)
+    recipe.add_variable(generator.scale, 1)
     # This is a peak-damping resolution term.
-    recipe.addVar(generator.qdamp, 0.01)
+    recipe.add_variable(generator.qdamp, 0.01)
     # This is a vibrational correlation term that sharpens peaks at low-r.
-    recipe.addVar(generator.delta2, 5)
+    recipe.add_variable(generator.delta2, 5)
 
     # Give the recipe away so it can be used!
     return recipe

docs/examples/crystalpdfall.py

@@ -111,24 +111,24 @@ def makeRecipe(
 
     # Now we vary and constrain Parameters as before.
     for par in phase_ni.sgpars:
-        recipe.addVar(par, name=par.name + "_ni")
-    delta2_ni = recipe.newVar("delta2_ni", 2.5)
+        recipe.add_variable(par, name=par.name + "_ni")
+    delta2_ni = recipe.create_new_variable("delta2_ni", 2.5)
     recipe.constrain(xgenerator_ni.delta2, delta2_ni)
     recipe.constrain(ngenerator_ni.delta2, delta2_ni)
     recipe.constrain(xgenerator_sini_ni.delta2, delta2_ni)
 
     for par in phase_si.sgpars:
-        recipe.addVar(par, name=par.name + "_si")
-    delta2_si = recipe.newVar("delta2_si", 2.5)
+        recipe.add_variable(par, name=par.name + "_si")
+    delta2_si = recipe.create_new_variable("delta2_si", 2.5)
     recipe.constrain(xgenerator_si.delta2, delta2_si)
     recipe.constrain(xgenerator_sini_si.delta2, delta2_si)
 
     # Now the experimental parameters
-    recipe.addVar(xgenerator_ni.scale, name="xscale_ni")
-    recipe.addVar(xgenerator_si.scale, name="xscale_si")
-    recipe.addVar(ngenerator_ni.scale, name="nscale_ni")
-    recipe.addVar(xcontribution_sini.scale, 1.0, "xscale_sini")
-    recipe.newVar("pscale_sini_ni", 0.8)
+    recipe.add_variable(xgenerator_ni.scale, name="xscale_ni")
+    recipe.add_variable(xgenerator_si.scale, name="xscale_si")
+    recipe.add_variable(ngenerator_ni.scale, name="nscale_ni")
+    recipe.add_variable(xcontribution_sini.scale, 1.0, "xscale_sini")
+    recipe.create_new_variable("pscale_sini_ni", 0.8)
     recipe.constrain(xgenerator_sini_ni.scale, "pscale_sini_ni")
     recipe.constrain(xgenerator_sini_si.scale, "1 - pscale_sini_ni")
 

docs/examples/crystalpdfobjcryst.py

@@ -90,18 +90,18 @@ def makeRecipe(ciffile, datname):
     # As before, we have one free lattice parameter ('a'). We can simplify
     # things by iterating through all the sgpars.
     for par in phase.sgpars:
-        recipe.addVar(par)
+        recipe.add_variable(par)
     # set the initial thermal factor to a non-zero value
     assert hasattr(recipe, "B11_0")
     recipe.B11_0 = 0.1
 
     # We now select non-structural parameters to refine.
     # This controls the scaling of the PDF.
-    recipe.addVar(generator.scale, 1)
+    recipe.add_variable(generator.scale, 1)
     # This is a peak-damping resolution term.
-    recipe.addVar(generator.qdamp, 0.01)
+    recipe.add_variable(generator.qdamp, 0.01)
     # This is a vibrational correlation term that sharpens peaks at low-r.
-    recipe.addVar(generator.delta2, 5)
+    recipe.add_variable(generator.delta2, 5)
 
     # Give the recipe away so it can be used!
     return recipe

docs/examples/crystalpdftwodata.py

@@ -114,21 +114,21 @@ def makeRecipe(ciffile, xdatname, ndatname):
     recipe.add_contribution(ncontribution)
 
     # Now we vary and constrain Parameters as before.
-    recipe.addVar(xgenerator.scale, 1, "xscale")
-    recipe.addVar(ngenerator.scale, 1, "nscale")
-    recipe.addVar(xgenerator.qdamp, 0.01, "xqdamp")
-    recipe.addVar(ngenerator.qdamp, 0.01, "nqdamp")
+    recipe.add_variable(xgenerator.scale, 1, "xscale")
+    recipe.add_variable(ngenerator.scale, 1, "nscale")
+    recipe.add_variable(xgenerator.qdamp, 0.01, "xqdamp")
+    recipe.add_variable(ngenerator.qdamp, 0.01, "nqdamp")
     # delta2 is a non-structual material property. Thus, we constrain together
     # delta2 Parameter from each PDFGenerator.
-    delta2 = recipe.newVar("delta2", 2)
+    delta2 = recipe.create_new_variable("delta2", 2)
     recipe.constrain(xgenerator.delta2, delta2)
     recipe.constrain(ngenerator.delta2, delta2)
 
     # We only need to constrain phase properties once since there is a single
     # ObjCrystCrystalParSet for the Crystal.
     phase = xgenerator.phase
     for par in phase.sgpars:
-        recipe.addVar(par)
+        recipe.add_variable(par)
     recipe.B11_0 = 0.1
 
     # Give the recipe away so it can be used!

docs/examples/crystalpdftwophase.py

@@ -89,16 +89,16 @@ def makeRecipe(niciffile, siciffile, datname):
     # Configure the fit variables
     # Start by configuring the scale factor and resolution factors.
     # We want the sum of the phase scale factors to be 1.
-    recipe.newVar("scale_ni", 0.1)
+    recipe.create_new_variable("scale_ni", 0.1)
     recipe.constrain(generator_ni.scale, "scale_ni")
     recipe.constrain(generator_si.scale, "1 - scale_ni")
     # We also want the resolution factor to be the same on each.
-    recipe.newVar("qdamp", 0.03)
+    recipe.create_new_variable("qdamp", 0.03)
     recipe.constrain(generator_ni.qdamp, "qdamp")
     recipe.constrain(generator_si.qdamp, "qdamp")
 
     # Vary the global scale as well.
-    recipe.addVar(contribution.scale, 1)
+    recipe.add_variable(contribution.scale, 1)
 
     # Now we can configure the structural parameters. Since we're using
     # ObjCrystCrystalParSets, the space group constraints are automatically
@@ -107,13 +107,13 @@ def makeRecipe(niciffile, siciffile, datname):
     # First the nickel parameters
     phase_ni = generator_ni.phase
     for par in phase_ni.sgpars:
-        recipe.addVar(par, name=par.name + "_ni")
-    recipe.addVar(generator_ni.delta2, name="delta2_ni")
+        recipe.add_variable(par, name=par.name + "_ni")
+    recipe.add_variable(generator_ni.delta2, name="delta2_ni")
     # Next the silicon parameters
     phase_si = generator_si.phase
     for par in phase_si.sgpars:
-        recipe.addVar(par, name=par.name + "_si")
-    recipe.addVar(generator_si.delta2, name="delta2_si")
+        recipe.add_variable(par, name=par.name + "_si")
+    recipe.add_variable(generator_si.delta2, name="delta2_si")
 
     # We have prior information from the earlier examples so we'll use it here
     # in the form of restraints.

docs/examples/debyemodel.py

@@ -139,9 +139,9 @@ def makeRecipe():
     # Specify which Parameters we want to refine.
 
     # Vary the offset
-    recipe.addVar(contribution.offset, 0)
+    recipe.add_variable(contribution.offset, 0)
     # We also vary the Debye temperature.
-    recipe.addVar(contribution.thetaD, 100)
+    recipe.add_variable(contribution.thetaD, 100)
 
     # We would like to 'suggest' that the offset should remain positive. This
     # is somethine that we know about the system that might help the refinement

docs/examples/debyemodelII.py

@@ -83,11 +83,11 @@ def makeRecipeII():
     # Vary the offset from each FitContribution separately, while keeping the
     # Debye temperatures the same. We give each offset variable a different
     # name in the recipe so it retains its identity.
-    recipe.addVar(recipe.lowT.offset, name="lowToffset")
-    recipe.addVar(recipe.highT.offset, name="highToffset")
+    recipe.add_variable(recipe.lowT.offset, name="lowToffset")
+    recipe.add_variable(recipe.highT.offset, name="highToffset")
     # We create a new Variable and use the recipe's "constrain" method to
     # associate the Debye temperature parameters with that variable.
-    recipe.newVar("thetaD", 100)
+    recipe.create_new_variable("thetaD", 100)
     recipe.constrain(recipe.lowT.thetaD, "thetaD")
     recipe.constrain(recipe.highT.thetaD, "thetaD")
     return recipe

docs/examples/ellipsoidsas.py

@@ -78,10 +78,10 @@ def makeRecipe(datname):
     # SASGenerator these are named like "radius_width".
     #
     # We want to fit the scale factor, radii and background factors.
-    recipe.addVar(generator.scale, 1)
-    recipe.addVar(generator.radius_a, 50)
-    recipe.addVar(generator.radius_b, 500)
-    recipe.addVar(generator.background, 0)
+    recipe.add_variable(generator.scale, 1)
+    recipe.add_variable(generator.radius_a, 50)
+    recipe.add_variable(generator.radius_b, 500)
+    recipe.add_variable(generator.background, 0)
 
     # Give the recipe away so it can be used!
     return recipe

docs/examples/gaussiangenerator.py

@@ -161,9 +161,9 @@ def makeRecipe():
     # that the Parameters belong to the GaussianGenerator, not the
     # FitContribution as in gaussianrecipe.py. We initialize parameters as in
     # gaussianrecipe.py so we can expect the same output.
-    recipe.addVar(generator.A, 1)
-    recipe.addVar(generator.x0, 5)
-    recipe.addVar(generator.sigma, name="sig")
+    recipe.add_variable(generator.A, 1)
+    recipe.add_variable(generator.x0, 5)
+    recipe.add_variable(generator.sigma, name="sig")
     recipe.sig.value = 1
 
     # Give the recipe away so it can be used!