setCalculationRange

cadenmyers13 · cadenmyers13 · commit eef57415ab14 · 2026-02-19T16:49:58.000-05:00
diff --git a/docs/examples/coreshellnp.py b/docs/examples/coreshellnp.py
@@ -45,7 +45,7 @@ def makeRecipe(stru1, stru2, datname):
     parser = PDFParser()
     parser.parseFile(datname)
     profile.load_parsed_data(parser)
-    profile.setCalculationRange(xmin=1.5, xmax=45, dx=0.1)
+    profile.set_calculation_range(xmin=1.5, xmax=45, dx=0.1)
 
     # The ProfileGenerator
     # In order to fit the core and shell phases simultaneously, we must use two
diff --git a/docs/examples/crystalpdf.py b/docs/examples/crystalpdf.py
@@ -56,7 +56,7 @@ def makeRecipe(ciffile, datname):
     parser = PDFParser()
     parser.parseFile(datname)
     profile.load_parsed_data(parser)
-    profile.setCalculationRange(xmax=20)
+    profile.set_calculation_range(xmax=20)
 
     # The ProfileGenerator
     # The PDFGenerator is for configuring and calculating a PDF profile. Here,
diff --git a/docs/examples/crystalpdfall.py b/docs/examples/crystalpdfall.py
@@ -40,7 +40,7 @@ def makeProfile(datafile):
     parser = PDFParser()
     parser.parseFile(datafile)
     profile.load_parsed_data(parser)
-    profile.setCalculationRange(xmax=20)
+    profile.set_calculation_range(xmax=20)
     return profile
 
 
diff --git a/docs/examples/crystalpdfobjcryst.py b/docs/examples/crystalpdfobjcryst.py
@@ -49,7 +49,7 @@ def makeRecipe(ciffile, datname):
     parser = PDFParser()
     parser.parseFile(datname)
     profile.load_parsed_data(parser)
-    profile.setCalculationRange(xmax=20)
+    profile.set_calculation_range(xmax=20)
 
     # The ProfileGenerator
     # This time we use the CreateCrystalFromCIF method of pyobjcryst.crystal to
diff --git a/docs/examples/crystalpdftwodata.py b/docs/examples/crystalpdftwodata.py
@@ -49,12 +49,12 @@ def makeRecipe(ciffile, xdatname, ndatname):
     parser = PDFParser()
     parser.parseFile(xdatname)
     xprofile.load_parsed_data(parser)
-    xprofile.setCalculationRange(xmax=20)
+    xprofile.set_calculation_range(xmax=20)
 
     parser = PDFParser()
     parser.parseFile(ndatname)
     nprofile.load_parsed_data(parser)
-    nprofile.setCalculationRange(xmax=20)
+    nprofile.set_calculation_range(xmax=20)
 
     # The ProfileGenerators
     # We need one of these for the x-ray data.
diff --git a/docs/examples/crystalpdftwophase.py b/docs/examples/crystalpdftwophase.py
@@ -46,7 +46,7 @@ def makeRecipe(niciffile, siciffile, datname):
     parser = PDFParser()
     parser.parseFile(datname)
     profile.load_parsed_data(parser)
-    profile.setCalculationRange(xmax=20)
+    profile.set_calculation_range(xmax=20)
 
     # The ProfileGenerator
     # In order to fit two phases simultaneously, we must use two PDFGenerators.
diff --git a/docs/examples/debyemodelII.py b/docs/examples/debyemodelII.py
@@ -77,8 +77,8 @@ def makeRecipeII():
     # Change the fit ranges of the Profiles embedded within the
     # FitContributions. We want to fit one of the contributions at low
     # temperature, and one at high.
-    lowT.profile.setCalculationRange(0, 150)
-    highT.profile.setCalculationRange(400, 500)
+    lowT.profile.set_calculation_range(0, 150)
+    highT.profile.set_calculation_range(400, 500)
 
     # Vary the offset from each FitContribution separately, while keeping the
     # Debye temperatures the same. We give each offset variable a different
@@ -102,8 +102,8 @@ def plotResults(recipe):
 
     # We want to extend the fitting range to its full extent so we can get a
     # nice full plot.
-    recipe.lowT.profile.setCalculationRange(xmin="obs", xmax="obs")
-    recipe.highT.profile.setCalculationRange(xmin="obs", xmax="obs")
+    recipe.lowT.profile.set_calculation_range(xmin="obs", xmax="obs")
+    recipe.highT.profile.set_calculation_range(xmin="obs", xmax="obs")
     T = recipe.lowT.profile.x
     U = recipe.lowT.profile.y
     # We can use a FitContribution's 'evaluateEquation' method to evaluate
diff --git a/docs/examples/nppdfcrystal.py b/docs/examples/nppdfcrystal.py
@@ -45,7 +45,7 @@ def makeRecipe(ciffile, grdata):
     pdfparser = PDFParser()
     pdfparser.parseFile(grdata)
     pdfprofile.load_parsed_data(pdfparser)
-    pdfprofile.setCalculationRange(xmin=0.1, xmax=20)
+    pdfprofile.set_calculation_range(xmin=0.1, xmax=20)
 
     pdfcontribution = FitContribution("pdf")
     pdfcontribution.set_profile(pdfprofile, xname="r")
diff --git a/docs/examples/nppdfobjcryst.py b/docs/examples/nppdfobjcryst.py
@@ -40,7 +40,7 @@ def makeRecipe(molecule, datname):
 
     # Load data and add it to the profile
     profile.loadtxt(datname)
-    profile.setCalculationRange(xmin=1.2, xmax=8)
+    profile.set_calculation_range(xmin=1.2, xmax=8)
 
     # The ProfileGenerator
     # Create a DebyePDFGenerator named "G".
diff --git a/docs/examples/nppdfsas.py b/docs/examples/nppdfsas.py
@@ -49,7 +49,7 @@ def makeRecipe(ciffile, grdata, iqdata):
     pdfparser = PDFParser()
     pdfparser.parseFile(grdata)
     pdfprofile.load_parsed_data(pdfparser)
-    pdfprofile.setCalculationRange(xmin=0.1, xmax=20)
+    pdfprofile.set_calculation_range(xmin=0.1, xmax=20)
 
     pdfcontribution = FitContribution("pdf")
     pdfcontribution.set_profile(pdfprofile, xname="r")
diff --git a/docs/examples/simplepdf.py b/docs/examples/simplepdf.py
@@ -35,7 +35,7 @@ def makeRecipe(ciffile, datname):
     # Work directly with a custom PDFContribution to load the data
     contribution = PDFContribution("nickel")
     contribution.loadData(datname)
-    contribution.setCalculationRange(xmin=1, xmax=20, dx=0.1)
+    contribution.set_calculation_range(xmin=1, xmax=20, dx=0.1)
 
     # and the phase
     stru = Structure()
diff --git a/docs/examples/simplepdftwophase.py b/docs/examples/simplepdftwophase.py
@@ -31,7 +31,7 @@ def makeRecipe(niciffile, siciffile, datname):
     # Load data and add it to the profile
     contribution = PDFContribution("nisi")
     contribution.loadData(datname)
-    contribution.setCalculationRange(xmax=20)
+    contribution.set_calculation_range(xmax=20)
 
     stru = loadCrystal(niciffile)
     contribution.addStructure("ni", stru)
diff --git a/src/diffpy/srfit/fitbase/profile.py b/src/diffpy/srfit/fitbase/profile.py
@@ -50,6 +50,13 @@
     removal_version,
 )
 
+setCalculationRange_dep_msg = build_deprecation_message(
+    base,
+    "setCalculationRange",
+    "set_calculation_range",
+    removal_version,
+)
+
 
 class Profile(Observable, Validatable):
     """Observed and calculated profile container.
@@ -213,7 +220,7 @@ def setObservedProfile(self, xobs, yobs, dyobs=None):
         self.set_observed_profile(xobs, yobs, dyobs)
         return
 
-    def setCalculationRange(self, xmin=None, xmax=None, dx=None):
+    def set_calculation_range(self, xmin=None, xmax=None, dx=None):
         """Set epsilon-inclusive calculation range.
 
         Adhere to the observed ``xobs`` points when ``dx`` is the same
@@ -317,6 +324,18 @@ def _isobs(a):
             self.setCalculationPoints(x1)
         return
 
+    @deprecated(setCalculationRange_dep_msg)
+    def setCalculationRange(self, xmin=None, xmax=None, dx=None):
+        """This function has been deprecated and will be removed in version
+        4.0.0.
+
+        Please use
+        diffpy.srfit.fitbase.profile.Profile.set_calculation_range
+        instead.
+        """
+        self.set_calculation_range(xmin, xmax, dx)
+        return
+
     def setCalculationPoints(self, x):
         """Set the calculation points.
 
diff --git a/src/diffpy/srfit/fitbase/simplerecipe.py b/src/diffpy/srfit/fitbase/simplerecipe.py
@@ -37,6 +37,13 @@
     removal_version,
 )
 
+setCalculationRange_dep_msg = build_deprecation_message(
+    base,
+    "setCalculationRange",
+    "set_calculation_range",
+    removal_version,
+)
+
 
 class SimpleRecipe(FitRecipe):
     """SimpleRecipe class.
@@ -163,7 +170,7 @@ def set_observed_profile(self, xobs, yobs, dyobs=None):
         Raises ValueError if len(yobs) != len(xobs)
         Raises ValueError if dyobs != None and len(dyobs) != len(xobs)
         """
-        return self.profile.setObservedProfile(xobs, yobs, dyobs)
+        return self.profile.set_observed_profile(xobs, yobs, dyobs)
 
     @deprecated(setObservedProfile_dep_msg)
     def setObservedProfile(self, xobs, yobs, dyobs=None):
@@ -176,7 +183,7 @@ def setObservedProfile(self, xobs, yobs, dyobs=None):
         """
         return self.set_observed_profile(xobs, yobs, dyobs)
 
-    def setCalculationRange(self, xmin=None, xmax=None, dx=None):
+    def set_calculation_range(self, xmin=None, xmax=None, dx=None):
         """Set epsilon-inclusive calculation range.
 
         Adhere to the observed ``xobs`` points when ``dx`` is the same
@@ -208,7 +215,17 @@ def setCalculationRange(self, xmin=None, xmax=None, dx=None):
         ValueError
             When xmin > xmax or if dx <= 0.  Also if dx > xmax - xmin.
         """
-        return self.profile.setCalculationRange(xmin, xmax, dx)
+        return self.profile.set_calculation_range(xmin, xmax, dx)
+
+    def setCalculationRange(self, xmin=None, xmax=None, dx=None):
+        """This function has been deprecated and will be removed in version
+        4.0.0.
+
+        Please use
+        diffpy.srfit.fitbase.simplerecipe.SimpleRecipe.set_calculation_range
+        instead.
+        """
+        return self.set_calculation_range(xmin, xmax, dx)
 
     def setCalculationPoints(self, x):
         """Set the calculation points.
diff --git a/tests/test_profile.py b/tests/test_profile.py
@@ -112,88 +112,111 @@ def testSetObservedProfile(self):
 
         return
 
-    def testSetCalculationRange(self):
-        """Test the setCalculationRange method."""
+    def test_set_calculation_range(self):
+        """Test the set_calculation_range method."""
         x = arange(2, 9.6, 0.5)
         y = array(x)
         dy = array(x)
         prof = self.profile
         # Check call before data arrays are present
-        self.assertRaises(AttributeError, prof.setCalculationRange)
-        self.assertRaises(AttributeError, prof.setCalculationRange, 0)
-        self.assertRaises(AttributeError, prof.setCalculationRange, 0, 5)
-        self.assertRaises(AttributeError, prof.setCalculationRange, 0, 5, 0.2)
+        self.assertRaises(AttributeError, prof.set_calculation_range)
+        self.assertRaises(AttributeError, prof.set_calculation_range, 0)
+        self.assertRaises(AttributeError, prof.set_calculation_range, 0, 5)
+        self.assertRaises(
+            AttributeError, prof.set_calculation_range, 0, 5, 0.2
+        )
         # assign data
         prof.set_observed_profile(x, y, dy)
         # Test normal execution w/o arguments
         self.assertTrue(array_equal(x, prof.x))
         self.assertTrue(array_equal(y, prof.y))
         self.assertTrue(array_equal(dy, prof.dy))
-        prof.setCalculationRange()
+        prof.set_calculation_range()
         self.assertTrue(array_equal(x, prof.x))
         self.assertTrue(array_equal(y, prof.y))
         self.assertTrue(array_equal(dy, prof.dy))
         # Test a lower bound < xmin
-        prof.setCalculationRange(xmin=0)
+        prof.set_calculation_range(xmin=0)
         self.assertTrue(array_equal(x, prof.x))
         self.assertTrue(array_equal(y, prof.y))
         self.assertTrue(array_equal(dy, prof.dy))
         # Test an upper bound > xmax
-        prof.setCalculationRange(xmax=100)
+        prof.set_calculation_range(xmax=100)
         self.assertTrue(array_equal(x, prof.x))
         self.assertTrue(array_equal(y, prof.y))
         self.assertTrue(array_equal(dy, prof.dy))
         # Test xmin > xmax
         self.assertRaises(
-            ValueError, prof.setCalculationRange, xmin=10, xmax=3
+            ValueError, prof.set_calculation_range, xmin=10, xmax=3
         )
         # Test xmax - xmin < dx
         self.assertRaises(
-            ValueError, prof.setCalculationRange, xmin=3, xmax=3.9, dx=1.0
+            ValueError, prof.set_calculation_range, xmin=3, xmax=3.9, dx=1.0
         )
         # Test dx <= 0
-        self.assertRaises(ValueError, prof.setCalculationRange, dx=0)
-        self.assertRaises(ValueError, prof.setCalculationRange, dx=-0.000001)
+        self.assertRaises(ValueError, prof.set_calculation_range, dx=0)
+        self.assertRaises(ValueError, prof.set_calculation_range, dx=-0.000001)
         # using string other than 'obs'
-        self.assertRaises(ValueError, prof.setCalculationRange, xmin="oobs")
-        self.assertRaises(ValueError, prof.setCalculationRange, xmax="oobs")
-        self.assertRaises(ValueError, prof.setCalculationRange, dx="oobs")
+        self.assertRaises(ValueError, prof.set_calculation_range, xmin="oobs")
+        self.assertRaises(ValueError, prof.set_calculation_range, xmax="oobs")
+        self.assertRaises(ValueError, prof.set_calculation_range, dx="oobs")
         # This should be alright
-        prof.setCalculationRange(3, 5)
-        prof.setCalculationRange(xmin="obs", xmax=7, dx=0.001)
+        prof.set_calculation_range(3, 5)
+        prof.set_calculation_range(xmin="obs", xmax=7, dx=0.001)
         self.assertEqual(5001, len(prof.x))
         self.assertEqual(len(prof.x), len(prof.y))
         self.assertEqual(len(prof.x), len(prof.dy))
         # Test an internal bound
-        prof.setCalculationRange(4, 7, dx="obs")
+        prof.set_calculation_range(4, 7, dx="obs")
         self.assertTrue(array_equal(prof.x, arange(4, 7.1, 0.5)))
         self.assertTrue(array_equal(prof.y, arange(4, 7.1, 0.5)))
         self.assertTrue(array_equal(prof.y, arange(4, 7.1, 0.5)))
         # test setting only one of the bounds
-        prof.setCalculationRange(xmin=3)
+        prof.set_calculation_range(xmin=3)
         self.assertTrue(array_equal(prof.x, arange(3, 7.1, 0.5)))
         self.assertTrue(array_equal(prof.x, prof.y))
         self.assertTrue(array_equal(prof.x, prof.dy))
-        prof.setCalculationRange(xmax=5.1)
+        prof.set_calculation_range(xmax=5.1)
         self.assertTrue(array_equal(prof.x, arange(3, 5.1, 0.5)))
         self.assertTrue(array_equal(prof.x, prof.y))
         self.assertTrue(array_equal(prof.x, prof.dy))
-        prof.setCalculationRange(dx=1)
+        prof.set_calculation_range(dx=1)
         self.assertTrue(array_equal(prof.x, arange(3, 5.1)))
         self.assertTrue(array_equal(prof.x, prof.y))
         self.assertTrue(array_equal(prof.x, prof.dy))
         # Test a new grid
-        prof.setCalculationRange(4.2, 7, 0.3)
+        prof.set_calculation_range(4.2, 7, 0.3)
         self.assertTrue(array_equal(prof.x, arange(4.2, 6.901, 0.3)))
         self.assertTrue(allclose(prof.x, prof.y))
         self.assertTrue(allclose(prof.x, prof.dy))
-        prof.setCalculationRange(xmin=4.2, xmax=6.001)
+        prof.set_calculation_range(xmin=4.2, xmax=6.001)
         self.assertTrue(array_equal(prof.x, arange(4.2, 6.001, 0.3)))
         # resample on a clipped grid
-        prof.setCalculationRange(dx=0.5)
+        prof.set_calculation_range(dx=0.5)
         self.assertTrue(array_equal(prof.x, arange(4.5, 6.1, 0.5)))
         return
 
+    def testSetCalculationRange(self):
+        """Test the deprecated setCalculationRange method.
+
+        Remove this test when setCalculationRange is removed in 4.0.0.
+        """
+        x = arange(2, 9.6, 0.5)
+        y = array(x)
+        dy = array(x)
+        prof = self.profile
+        prof.set_observed_profile(x, y, dy)
+        prof.setCalculationRange()
+        # Test normal execution w/o arguments
+        self.assertTrue(array_equal(x, prof.x))
+        self.assertTrue(array_equal(y, prof.y))
+        self.assertTrue(array_equal(dy, prof.dy))
+        prof.setCalculationRange()
+        self.assertTrue(array_equal(x, prof.x))
+        self.assertTrue(array_equal(y, prof.y))
+        self.assertTrue(array_equal(dy, prof.dy))
+        return
+
     def testSetCalculationPoints(self):
         """Test the setCalculationPoints method."""
         prof = self.profile
