From 234943cdceaf12725b760114f34d4eec3f8851fe Mon Sep 17 00:00:00 2001 From: Caden Myers Date: Tue, 27 Oct 2026 13:36:24 -0400 Subject: [PATCH] feat: deprecate the camelCase methods and short attribute names in diffpy.srfit.structure Add snake_case names matching diffpy.cmistructure for the 36 camelCase methods #236 left out, with @deprecated forwarders, and deprecated properties for angunits, scat, res, matoms, sg, strups and idx. Move internal callers and regular tests to the new names. Fix ObjCrystMoleculeParSet.get_lattice (called the missing newPar) and wrap_stretch_mode_parameters (called the missing AddAtoms). Co-Authored-By: Claude Opus 5.5 --- docs/source/api/diffpy.srfit.structure.rst | 4 + news/structure-names-dep.rst | 26 + src/diffpy/srfit/pdf/basepdfgenerator.py | 2 +- src/diffpy/srfit/structure/__init__.py | 8 +- .../srfit/structure/basestructureparset.py | 72 +- src/diffpy/srfit/structure/cctbxparset.py | 158 +++- src/diffpy/srfit/structure/diffpyparset.py | 43 +- src/diffpy/srfit/structure/objcrystparset.py | 784 ++++++++++++++--- src/diffpy/srfit/structure/sgconstraints.py | 95 ++- src/diffpy/srfit/structure/srrealparset.py | 44 +- tests/deprecated/test_pdf_deprecations.py | 4 +- .../deprecated/test_structure_deprecations.py | 798 +++++++++++++++++- tests/test_diffpyparset.py | 2 +- tests/test_objcrystparset.py | 88 +- tests/test_sgconstraints.py | 10 +- 15 files changed, 1930 insertions(+), 208 deletions(-) create mode 100644 news/structure-names-dep.rst diff --git a/docs/source/api/diffpy.srfit.structure.rst b/docs/source/api/diffpy.srfit.structure.rst index 59063abd..a2f08d59 100644 --- a/docs/source/api/diffpy.srfit.structure.rst +++ b/docs/source/api/diffpy.srfit.structure.rst @@ -3,6 +3,10 @@ diffpy.srfit.structure package ============================== +.. deprecated:: 3.5.0 + ``diffpy.srfit.structure`` has moved to ``diffpy.cmistructure`` and will + be removed in version 4.0.0. Please use ``diffpy.cmistructure`` instead. + .. automodule:: diffpy.srfit.structure :members: :undoc-members: diff --git a/news/structure-names-dep.rst b/news/structure-names-dep.rst new file mode 100644 index 00000000..ea4dcdf6 --- /dev/null +++ b/news/structure-names-dep.rst @@ -0,0 +1,26 @@ +**Added:** + +* The snake_case names of the structure adapter methods, which they have in ``diffpy.cmistructure``: ``can_adapt``, ``get_lattice``, ``get_scatterers``, ``get_space_group``, ``use_symmetry``, ``using_symmetry``, ``is_dummy``, ``has_scatterers``, ``wrap_restraints``, ``wrap_stretch_mode_parameters``, ``restrain_bond_length``, ``restrain_bond_angle``, ``restrain_dihedral_angle`` and their ``*_parameter`` forms, ``add_bond_length_parameter``, ``add_bond_angle_parameter``, ``add_dihedral_angle_parameter``, ``StretchModeParameter.add_atoms`` and ``BaseSpaceGroupParameters.add_parameter``. +* The attributes ``.angle_units``, ``.scatterer``, ``.restraint``, ``.mutated_atoms``, ``.space_group``, ``.structure_parameter_set`` and ``.index``, which they are called in ``diffpy.cmistructure``. + +**Changed:** + +* + +**Deprecated:** + +* The camelCase methods of the ``diffpy.srfit.structure`` adapters (``canAdapt``, ``getLattice``, ``getScatterers``, ``getSpaceGroup``, ``useSymmetry``, ``usingSymmetry``, ``isDummy``, ``hasScatterers``, ``wrapRestraints``, ``wrapStretchModeParameters``, the ``restrainBond*`` and ``restrainDihedral*`` methods, the ``add*Parameter`` methods of ``ObjCrystMoleculeParSet``, ``StretchModeParameter.addAtoms`` and ``BaseSpaceGroupParameters.addParameter``). Please use their snake_case names in ``diffpy.cmistructure`` instead. +* The attributes ``.angunits``, ``.scat``, ``.res``, ``.matoms``, ``.sg``, ``.strups`` and ``.idx``. Please use ``.angle_units``, ``.scatterer``, ``.restraint``, ``.mutated_atoms``, ``.space_group``, ``.structure_parameter_set`` and ``.index`` in ``diffpy.cmistructure`` instead. + +**Removed:** + +* + +**Fixed:** + +* ``ObjCrystMoleculeParSet.get_lattice`` no longer raises ``AttributeError``. It called ``newPar``, which ``ParameterSet`` doesn't have. +* ``ObjCrystMoleculeParSet.wrap_stretch_mode_parameters`` no longer raises ``AttributeError`` for a molecule with stretch modes. It called ``AddAtoms``, which ``StretchModeParameter`` doesn't have. + +**Security:** + +* diff --git a/src/diffpy/srfit/pdf/basepdfgenerator.py b/src/diffpy/srfit/pdf/basepdfgenerator.py index 79a0f08e..3ec4a6bb 100644 --- a/src/diffpy/srfit/pdf/basepdfgenerator.py +++ b/src/diffpy/srfit/pdf/basepdfgenerator.py @@ -430,7 +430,7 @@ def set_structure_from_parset(self, parset, periodic=True): self.add_parameter_set(parset) # Set periodicity - self._phase.useSymmetry(periodic) + self._phase.use_symmetry(periodic) return @deprecated(setPhase_dep_msg) diff --git a/src/diffpy/srfit/structure/__init__.py b/src/diffpy/srfit/structure/__init__.py index 70042f83..23eab322 100644 --- a/src/diffpy/srfit/structure/__init__.py +++ b/src/diffpy/srfit/structure/__init__.py @@ -74,22 +74,22 @@ def structure_to_parameter_set(name, structure): """ from diffpy.srfit.structure.diffpyparset import DiffpyStructureParSet - if DiffpyStructureParSet.canAdapt(structure): + if DiffpyStructureParSet.can_adapt(structure): return DiffpyStructureParSet(name, structure) from diffpy.srfit.structure.objcrystparset import ObjCrystCrystalParSet - if ObjCrystCrystalParSet.canAdapt(structure): + if ObjCrystCrystalParSet.can_adapt(structure): return ObjCrystCrystalParSet(name, structure) from diffpy.srfit.structure.objcrystparset import ObjCrystMoleculeParSet - if ObjCrystMoleculeParSet.canAdapt(structure): + if ObjCrystMoleculeParSet.can_adapt(structure): return ObjCrystMoleculeParSet(name, structure) from diffpy.srfit.structure.cctbxparset import CCTBXCrystalParSet - if CCTBXCrystalParSet.canAdapt(structure): + if CCTBXCrystalParSet.can_adapt(structure): return CCTBXCrystalParSet(name, structure) raise TypeError("Unadaptable structure format") diff --git a/src/diffpy/srfit/structure/basestructureparset.py b/src/diffpy/srfit/structure/basestructureparset.py index 1facd01a..e45de08e 100644 --- a/src/diffpy/srfit/structure/basestructureparset.py +++ b/src/diffpy/srfit/structure/basestructureparset.py @@ -34,6 +34,34 @@ ) +parset_base = "diffpy.srfit.structure.basestructureparset.BaseStructureParSet" +parset_new_base = "diffpy.cmistructure.basestructureparset.BaseStructureParSet" + +parset_canAdapt_dep_msg = build_deprecation_message( + parset_base, + "canAdapt", + "can_adapt", + removal_version, + new_base=parset_new_base, +) + +parset_getLattice_dep_msg = build_deprecation_message( + parset_base, + "getLattice", + "get_lattice", + removal_version, + new_base=parset_new_base, +) + +parset_getScatterers_dep_msg = build_deprecation_message( + parset_base, + "getScatterers", + "get_scatterers", + removal_version, + new_base=parset_new_base, +) + + class BaseStructureParSet(ParameterSet): """Base class for structure adapters. @@ -65,23 +93,46 @@ def stru(self, value): self.structure = value @classmethod - def canAdapt(self, stru): + def can_adapt(self, stru): """Return whether the structure can be adapted by this class.""" return False - def getLattice(self): + @classmethod + @deprecated(parset_canAdapt_dep_msg) + def canAdapt(self, stru): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.basestructureparset.BaseStructureParSet.can_adapt + instead. + """ + return self.can_adapt(stru) + + def get_lattice(self): """Get a ParameterSet containing the lattice Parameters. The returned ParameterSet may contain other Parameters than the lattice Parameters. It is assumed that the lattice parameters are named "a", "b", "c", "alpha", "beta", "gamma". - Lattice must also have the "angunits" attribute, which is either - "deg" or "rad", to signify degrees or radians. + Lattice must also have the "angle_units" attribute, which is + either "deg" or "rad", to signify degrees or radians. """ raise NotImplementedError("The must be overloaded") - def getScatterers(self): + @deprecated(parset_getLattice_dep_msg) + def getLattice(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.basestructureparset.BaseStructureParSet.get_lattice + instead. + """ + return self.get_lattice() + + def get_scatterers(self): """Get a list of ParameterSets that represents the scatterers. The site positions must be accessible from the list entries via @@ -90,3 +141,14 @@ def getScatterers(self): isotropic, anisotropic) depends on the adapted structure. """ raise NotImplementedError("The must be overloaded") + + @deprecated(parset_getScatterers_dep_msg) + def getScatterers(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.basestructureparset.BaseStructureParSet.get_scatterers + instead. + """ + return self.get_scatterers() diff --git a/src/diffpy/srfit/structure/cctbxparset.py b/src/diffpy/srfit/structure/cctbxparset.py index 65e14184..1eb4a1e9 100644 --- a/src/diffpy/srfit/structure/cctbxparset.py +++ b/src/diffpy/srfit/structure/cctbxparset.py @@ -30,10 +30,55 @@ from diffpy.srfit.fitbase.parameter import ParameterAdapter from diffpy.srfit.fitbase.parameterset import ParameterSet from diffpy.srfit.structure.basestructureparset import BaseStructureParSet +from diffpy.utils._deprecator import build_deprecation_message, deprecated __all__ = ["CCTBXScattererParSet", "CCTBXUnitCellParSet", "CCTBXCrystalParSet"] +removal_version = "4.0.0" + +scatterer_base = "diffpy.srfit.structure.cctbxparset.CCTBXScattererParSet" +scatterer_new_base = "diffpy.cmistructure.cctbxparset.CCTBXScattererParSet" + +scatterer_strups_dep_msg = build_deprecation_message( + scatterer_base, + "strups", + "structure_parameter_set", + removal_version, + new_base=scatterer_new_base, +) + +scatterer_idx_dep_msg = build_deprecation_message( + scatterer_base, + "idx", + "index", + removal_version, + new_base=scatterer_new_base, +) + +unit_cell_base = "diffpy.srfit.structure.cctbxparset.CCTBXUnitCellParSet" +unit_cell_new_base = "diffpy.cmistructure.cctbxparset.CCTBXUnitCellParSet" + +unit_cell_strups_dep_msg = build_deprecation_message( + unit_cell_base, + "strups", + "structure_parameter_set", + removal_version, + new_base=unit_cell_new_base, +) + +crystal_base = "diffpy.srfit.structure.cctbxparset.CCTBXCrystalParSet" +crystal_new_base = "diffpy.cmistructure.cctbxparset.CCTBXCrystalParSet" + +crystal_getSpaceGroup_dep_msg = build_deprecation_message( + crystal_base, + "getSpaceGroup", + "get_space_group", + removal_version, + new_base=crystal_new_base, +) + + class CCTBXScattererParSet(ParameterSet): """A wrapper for cctbx.xray.scatterer. @@ -53,6 +98,39 @@ class CCTBXScattererParSet(ParameterSet): Isotropic scattering factor (ParameterAdapter). """ + @property + @deprecated(scatterer_idx_dep_msg) + def idx(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use diffpy.cmistructure.cctbxparset.CCTBXScattererParSet.index + instead. + """ + return self.index + + @idx.setter + @deprecated(scatterer_idx_dep_msg) + def idx(self, value): + self.index = value + + @property + @deprecated(scatterer_strups_dep_msg) + def strups(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.cctbxparset.CCTBXScattererParSet.structure_parameter_set + instead. + """ + return self.structure_parameter_set + + @strups.setter + @deprecated(scatterer_strups_dep_msg) + def strups(self, value): + self.structure_parameter_set = value + def __init__(self, name, strups, idx): """Initialize. @@ -66,8 +144,8 @@ def __init__(self, name, strups, idx): The index of the scatterer in the structure. """ ParameterSet.__init__(self, name) - self.strups = strups - self.idx = idx + self.structure_parameter_set = strups + self.index = idx # x, y, z, occupancy self.add_parameter( @@ -92,32 +170,48 @@ def __init__(self, name, strups, idx): def _xyzgetter(self, i): def f(dummy): - return self.strups.structure.scatterers()[self.idx].site[i] + return self.structure_parameter_set.structure.scatterers()[ + self.index + ].site[i] return f def _xyzsetter(self, i): def f(dummy, value): - xyz = list(self.strups.structure.scatterers()[self.idx].site) + xyz = list( + self.structure_parameter_set.structure.scatterers()[ + self.index + ].site + ) xyz[i] = value - self.strups.structure.scatterers()[self.idx].site = tuple(xyz) + self.structure_parameter_set.structure.scatterers()[ + self.index + ].site = tuple(xyz) return return f def _getocc(self, dummy): - return self.strups.structure.scatterers()[self.idx].occupancy + return self.structure_parameter_set.structure.scatterers()[ + self.index + ].occupancy def _setocc(self, dummy, value): - self.strups.structure.scatterers()[self.idx].occupancy = value + self.structure_parameter_set.structure.scatterers()[ + self.index + ].occupancy = value return def _getuiso(self, dummy): - return self.strups.structure.scatterers()[self.idx].u_iso + return self.structure_parameter_set.structure.scatterers()[ + self.index + ].u_iso def _setuiso(self, dummy, value): - self.strups.structure.scatterers()[self.idx].u_iso = value + self.structure_parameter_set.structure.scatterers()[ + self.index + ].u_iso = value return def _getelem(self): @@ -150,6 +244,23 @@ class CCTBXUnitCellParSet(ParameterSet): Unit cell parameters (ParameterAdapter). """ + @property + @deprecated(unit_cell_strups_dep_msg) + def strups(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.cctbxparset.CCTBXUnitCellParSet.structure_parameter_set + instead. + """ + return self.structure_parameter_set + + @strups.setter + @deprecated(unit_cell_strups_dep_msg) + def strups(self, value): + self.structure_parameter_set = value + def __init__(self, strups): """Initialize. @@ -160,8 +271,10 @@ def __init__(self, strups): and the unit cell we're wrapper. """ ParameterSet.__init__(self, "unitcell") - self.strups = strups - self._latpars = list(self.strups.structure.unit_cell().parameters()) + self.structure_parameter_set = strups + self._latpars = list( + self.structure_parameter_set.structure.unit_cell().parameters() + ) self.add_parameter( ParameterAdapter("a", None, self._latgetter(0), self._latsetter(0)) @@ -201,7 +314,7 @@ def _latsetter(self, i): def f(dummy, value): self._latpars[i] = value - self.strups._update = True + self.structure_parameter_set._update = True return return f @@ -255,7 +368,7 @@ def __init__(self, name, stru): # Constrain the lattice from diffpy.srfit.structure.sgconstraints import _constrain_space_group - symbol = self.getSpaceGroup() + symbol = self.get_space_group() _constrain_space_group(self, symbol) return @@ -293,7 +406,7 @@ def update(self): return @classmethod - def canAdapt(self, stru): + def can_adapt(self, stru): """Return whether the structure can be adapted by this class.""" try: from cctbx.crystal import special_position_settings @@ -301,11 +414,11 @@ def canAdapt(self, stru): return False return isinstance(stru, special_position_settings) - def getLattice(self): + def get_lattice(self): """Get the ParameterSet containing the lattice Parameters.""" return self.unitcell - def getScatterers(self): + def get_scatterers(self): """Get a list of ParameterSets that represents the scatterers. The site positions must be accessible from the list entries via @@ -315,11 +428,22 @@ def getScatterers(self): """ return self.scatterers - def getSpaceGroup(self): + def get_space_group(self): """Get the HM space group symbol for the structure.""" sg = self.structure.space_group() t = sg.type() return t.lookup_symbol() + @deprecated(crystal_getSpaceGroup_dep_msg) + def getSpaceGroup(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.cctbxparset.CCTBXCrystalParSet.get_space_group + instead. + """ + return self.get_space_group() + # End class CCTBXCrystalParSet diff --git a/src/diffpy/srfit/structure/diffpyparset.py b/src/diffpy/srfit/structure/diffpyparset.py index 7bcf800c..a6e4ef5f 100644 --- a/src/diffpy/srfit/structure/diffpyparset.py +++ b/src/diffpy/srfit/structure/diffpyparset.py @@ -35,9 +35,23 @@ from diffpy.srfit.fitbase.parameterset import ParameterSet from diffpy.srfit.structure.srrealparset import SrRealParSet from diffpy.srfit.util.argbinders import bind2nd - +from diffpy.utils._deprecator import build_deprecation_message, deprecated # Accessor for xyz of atoms +removal_version = "4.0.0" + +lattice_base = "diffpy.srfit.structure.diffpyparset.DiffpyLatticeParSet" +lattice_new_base = "diffpy.cmistructure.diffpyparset.DiffpyLatticeParSet" + +lattice_angunits_dep_msg = build_deprecation_message( + lattice_base, + "angunits", + "angle_units", + removal_version, + new_base=lattice_new_base, +) + + class _xyzgetter(object): def __init__(self, i): @@ -185,7 +199,7 @@ class DiffpyLatticeParSet(ParameterSet): The diffpy.structure.Lattice this is adapting name Always "lattice" - angunits + angle_units "deg", the units of angle Parameters @@ -204,6 +218,23 @@ class DiffpyLatticeParSet(ParameterSet): Unit cell parameters (ParameterAdapter). """ + @property + @deprecated(lattice_angunits_dep_msg) + def angunits(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.diffpyparset.DiffpyLatticeParSet.angle_units + instead. + """ + return self.angle_units + + @angunits.setter + @deprecated(lattice_angunits_dep_msg) + def angunits(self, value): + self.angle_units = value + def __init__(self, lattice): """Initialize. @@ -213,7 +244,7 @@ def __init__(self, lattice): A diffpy.structure.Lattice instance """ ParameterSet.__init__(self, "lattice") - self.angunits = "deg" + self.angle_units = "deg" self.lattice = lattice lat = lattice self.add_parameter( @@ -307,18 +338,18 @@ def __init__(self, name, stru): def __repr__(self): return repr(self.structure) - def getLattice(self): + def get_lattice(self): """Get the ParameterSet containing the lattice Parameters.""" return self.lattice @classmethod - def canAdapt(self, stru): + def can_adapt(self, stru): """Return whether the structure can be adapted by this class.""" from diffpy.structure import Structure return isinstance(stru, Structure) - def getScatterers(self): + def get_scatterers(self): """Get a list of ParameterSets that represents the scatterers. The site positions must be accessible from the list entries via diff --git a/src/diffpy/srfit/structure/objcrystparset.py b/src/diffpy/srfit/structure/objcrystparset.py index 1a0d0016..a8f6e03e 100644 --- a/src/diffpy/srfit/structure/objcrystparset.py +++ b/src/diffpy/srfit/structure/objcrystparset.py @@ -107,6 +107,218 @@ ) +scatterer_base = ( + "diffpy.srfit.structure.objcrystparset.ObjCrystScattererParSet" +) +scatterer_new_base = ( + "diffpy.cmistructure.objcrystparset.ObjCrystScattererParSet" +) + +scatterer_scat_dep_msg = build_deprecation_message( + scatterer_base, + "scat", + "scatterer", + removal_version, + new_base=scatterer_new_base, +) + +scatterer_isDummy_dep_msg = build_deprecation_message( + scatterer_base, + "isDummy", + "is_dummy", + removal_version, + new_base=scatterer_new_base, +) + +scatterer_hasScatterers_dep_msg = build_deprecation_message( + scatterer_base, + "hasScatterers", + "has_scatterers", + removal_version, + new_base=scatterer_new_base, +) + +molecule_base = "diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet" +molecule_new_base = "diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet" + +molecule_canAdapt_dep_msg = build_deprecation_message( + molecule_base, + "canAdapt", + "can_adapt", + removal_version, + new_base=molecule_new_base, +) + +molecule_useSymmetry_dep_msg = build_deprecation_message( + molecule_base, + "useSymmetry", + "use_symmetry", + removal_version, + new_base=molecule_new_base, +) + +molecule_usingSymmetry_dep_msg = build_deprecation_message( + molecule_base, + "usingSymmetry", + "using_symmetry", + removal_version, + new_base=molecule_new_base, +) + +molecule_getLattice_dep_msg = build_deprecation_message( + molecule_base, + "getLattice", + "get_lattice", + removal_version, + new_base=molecule_new_base, +) + +molecule_getScatterers_dep_msg = build_deprecation_message( + molecule_base, + "getScatterers", + "get_scatterers", + removal_version, + new_base=molecule_new_base, +) + +molecule_wrapRestraints_dep_msg = build_deprecation_message( + molecule_base, + "wrapRestraints", + "wrap_restraints", + removal_version, + new_base=molecule_new_base, +) + +molecule_wrapStretchModeParameters_dep_msg = build_deprecation_message( + molecule_base, + "wrapStretchModeParameters", + "wrap_stretch_mode_parameters", + removal_version, + new_base=molecule_new_base, +) + +molecule_restrainBondLength_dep_msg = build_deprecation_message( + molecule_base, + "restrainBondLength", + "restrain_bond_length", + removal_version, + new_base=molecule_new_base, +) + +molecule_restrainBondLengthParameter_dep_msg = build_deprecation_message( + molecule_base, + "restrainBondLengthParameter", + "restrain_bond_length_parameter", + removal_version, + new_base=molecule_new_base, +) + +molecule_restrainBondAngle_dep_msg = build_deprecation_message( + molecule_base, + "restrainBondAngle", + "restrain_bond_angle", + removal_version, + new_base=molecule_new_base, +) + +molecule_restrainBondAngleParameter_dep_msg = build_deprecation_message( + molecule_base, + "restrainBondAngleParameter", + "restrain_bond_angle_parameter", + removal_version, + new_base=molecule_new_base, +) + +molecule_restrainDihedralAngle_dep_msg = build_deprecation_message( + molecule_base, + "restrainDihedralAngle", + "restrain_dihedral_angle", + removal_version, + new_base=molecule_new_base, +) + +molecule_restrainDihedralAngleParameter_dep_msg = build_deprecation_message( + molecule_base, + "restrainDihedralAngleParameter", + "restrain_dihedral_angle_parameter", + removal_version, + new_base=molecule_new_base, +) + +molecule_addBondLengthParameter_dep_msg = build_deprecation_message( + molecule_base, + "addBondLengthParameter", + "add_bond_length_parameter", + removal_version, + new_base=molecule_new_base, +) + +molecule_addBondAngleParameter_dep_msg = build_deprecation_message( + molecule_base, + "addBondAngleParameter", + "add_bond_angle_parameter", + removal_version, + new_base=molecule_new_base, +) + +molecule_addDihedralAngleParameter_dep_msg = build_deprecation_message( + molecule_base, + "addDihedralAngleParameter", + "add_dihedral_angle_parameter", + removal_version, + new_base=molecule_new_base, +) + +restraint_base = ( + "diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeRestraint" +) +restraint_new_base = ( + "diffpy.cmistructure.objcrystparset.ObjCrystMoleculeRestraint" +) + +restraint_res_dep_msg = build_deprecation_message( + restraint_base, + "res", + "restraint", + removal_version, + new_base=restraint_new_base, +) + +stretch_mode_base = ( + "diffpy.srfit.structure.objcrystparset.StretchModeParameter" +) +stretch_mode_new_base = ( + "diffpy.cmistructure.objcrystparset.StretchModeParameter" +) + +stretch_mode_matoms_dep_msg = build_deprecation_message( + stretch_mode_base, + "matoms", + "mutated_atoms", + removal_version, + new_base=stretch_mode_new_base, +) + +stretch_mode_addAtoms_dep_msg = build_deprecation_message( + stretch_mode_base, + "addAtoms", + "add_atoms", + removal_version, + new_base=stretch_mode_new_base, +) + +crystal_base = "diffpy.srfit.structure.objcrystparset.ObjCrystCrystalParSet" +crystal_new_base = "diffpy.cmistructure.objcrystparset.ObjCrystCrystalParSet" + +crystal_angunits_dep_msg = build_deprecation_message( + crystal_base, + "angunits", + "angle_units", + removal_version, + new_base=crystal_new_base, +) + + class ObjCrystScattererParSet(ParameterSet): """A base adaptor for an Objcryst Scatterer. @@ -117,7 +329,7 @@ class ObjCrystScattererParSet(ParameterSet): Attributes ---------- - scat + scatterer The adapted pyobjcryst object. parent The ParameterSet this belongs to @@ -129,6 +341,23 @@ class ObjCrystScattererParSet(ParameterSet): (ParameterWraper) """ + @property + @deprecated(scatterer_scat_dep_msg) + def scat(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystScattererParSet.scatterer + instead. + """ + return self.scatterer + + @scat.setter + @deprecated(scatterer_scat_dep_msg) + def scat(self, value): + self.scatterer = value + def __init__(self, name, scat, parent): """Initialize. @@ -142,25 +371,47 @@ def __init__(self, name, scat, parent): The ParameterSet this belongs to """ ParameterSet.__init__(self, name) - self.scat = scat + self.scatterer = scat self.parent = parent # x, y, z, occ - self.add_parameter(ParameterAdapter("x", self.scat, attr="X")) - self.add_parameter(ParameterAdapter("y", self.scat, attr="Y")) - self.add_parameter(ParameterAdapter("z", self.scat, attr="Z")) + self.add_parameter(ParameterAdapter("x", self.scatterer, attr="X")) + self.add_parameter(ParameterAdapter("y", self.scatterer, attr="Y")) + self.add_parameter(ParameterAdapter("z", self.scatterer, attr="Z")) self.add_parameter( - ParameterAdapter("occ", self.scat, attr="Occupancy") + ParameterAdapter("occ", self.scatterer, attr="Occupancy") ) return - def isDummy(self): + def is_dummy(self): """Indicate whether this scatterer is a dummy atom.""" return False - def hasScatterers(self): + @deprecated(scatterer_isDummy_dep_msg) + def isDummy(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystScattererParSet.is_dummy + instead. + """ + return self.is_dummy() + + def has_scatterers(self): """Indicate if this scatterer has its own scatterers.""" - return hasattr(self, "getScatterers") + return hasattr(self, "get_scatterers") + + @deprecated(scatterer_hasScatterers_dep_msg) + def hasScatterers(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystScattererParSet.has_scatterers + instead. + """ + return self.has_scatterers() # End class ObjCrystScattererParSet @@ -173,7 +424,7 @@ class ObjCrystAtomParSet(ObjCrystScattererParSet): Attributes ---------- - scat + scatterer The adapted pyobjcryst.atom.Atom. element Non-refinable name of the element (property). @@ -233,7 +484,7 @@ def __init__(self, name, atom, parent): def _getelem(self): """Getter for the element type.""" - return self.scat.GetScatteringPower().GetSymbol() + return self.scatterer.GetScatteringPower().GetSymbol() element = property(_getelem) @@ -248,7 +499,7 @@ class ObjCrystMoleculeParSet(ObjCrystScattererParSet): Attributes ---------- - scat + scatterer The adapted pyobjcryst.molecule.Molecule. structure The adapted pyobjcryst.molecule.Molecule. @@ -302,10 +553,10 @@ def __init__(self, name, molecule, parent=None): self.structure = molecule # Add orientation quaternion - self.add_parameter(ParameterAdapter("q0", self.scat, attr="Q0")) - self.add_parameter(ParameterAdapter("q1", self.scat, attr="Q1")) - self.add_parameter(ParameterAdapter("q2", self.scat, attr="Q2")) - self.add_parameter(ParameterAdapter("q3", self.scat, attr="Q3")) + self.add_parameter(ParameterAdapter("q0", self.scatterer, attr="Q0")) + self.add_parameter(ParameterAdapter("q1", self.scatterer, attr="Q1")) + self.add_parameter(ParameterAdapter("q2", self.scatterer, attr="Q2")) + self.add_parameter(ParameterAdapter("q3", self.scatterer, attr="Q3")) # Wrap the MolAtoms within the molecule self.atoms = [] @@ -328,28 +579,62 @@ def __init__(self, name, molecule, parent=None): return @classmethod - def canAdapt(self, stru): + def can_adapt(self, stru): """Return whether the structure can be adapted by this class.""" from pyobjcryst.molecule import Molecule return isinstance(stru, Molecule) + @classmethod + @deprecated(molecule_canAdapt_dep_msg) + def canAdapt(self, stru): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.can_adapt + instead. + """ + return self.can_adapt(stru) + # Part of SrRealParSet interface - def useSymmetry(self, use=True): + def use_symmetry(self, use=True): """Set this structure to use symmetry. This structure object does not support symmetry. """ return + @deprecated(molecule_useSymmetry_dep_msg) + def useSymmetry(self, use=True): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.use_symmetry + instead. + """ + return self.use_symmetry(use) + # Part of SrRealParSet interface - def usingSymmetry(self): + def using_symmetry(self): """Check if symmetry is being used. This structure object does not support symmetry. """ return False + @deprecated(molecule_usingSymmetry_dep_msg) + def usingSymmetry(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.using_symmetry + instead. + """ + return self.using_symmetry() + # Part of SrRealParSet interface def _get_srreal_structure(self): """Get the structure object for use with SrReal calculators. @@ -359,19 +644,30 @@ def _get_srreal_structure(self): """ return self.structure - def getLattice(self): + def get_lattice(self): """Get the ParameterSet containing the lattice Parameters.""" lattice = ParameterSet("lattice") - lattice.newPar("a", 1.0) - lattice.newPar("b", 1.0) - lattice.newPar("c", 1.0) - lattice.newPar("alpha", 90) - lattice.newPar("beta", 90) - lattice.newPar("gamma", 90) - lattice.angunits = "deg" + lattice.new_parameter("a", 1.0) + lattice.new_parameter("b", 1.0) + lattice.new_parameter("c", 1.0) + lattice.new_parameter("alpha", 90) + lattice.new_parameter("beta", 90) + lattice.new_parameter("gamma", 90) + lattice.angle_units = "deg" return lattice - def getScatterers(self): + @deprecated(molecule_getLattice_dep_msg) + def getLattice(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.get_lattice + instead. + """ + return self.get_lattice() + + def get_scatterers(self): """Get a list of ParameterSets that represents the scatterers. The site positions must be accessible from the list entries via @@ -381,7 +677,18 @@ def getScatterers(self): """ return self.atoms - def wrapRestraints(self): + @deprecated(molecule_getScatterers_dep_msg) + def getScatterers(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.get_scatterers + instead. + """ + return self.get_scatterers() + + def wrap_restraints(self): """Wrap the restraints implicit to the molecule. This will wrap MolBonds, MolBondAngles and MolDihedralAngles of @@ -389,21 +696,32 @@ def wrapRestraints(self): """ # Wrap restraints. Restraints wrapped in this way cannot be modified # from within this class. - for b in self.scat.GetBondList(): + for b in self.scatterer.GetBondList(): res = ObjCrystMoleculeRestraint(b) self.register_soft_bounds(res) - for ba in self.scat.GetBondAngleList(): + for ba in self.scatterer.GetBondAngleList(): res = ObjCrystMoleculeRestraint(ba) self.register_soft_bounds(res) - for da in self.scat.GetDihedralAngleList(): + for da in self.scatterer.GetDihedralAngleList(): res = ObjCrystMoleculeRestraint(da) self.register_soft_bounds(res) return - def wrapStretchModeParameters(self): + @deprecated(molecule_wrapRestraints_dep_msg) + def wrapRestraints(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.wrap_restraints + instead. + """ + return self.wrap_restraints() + + def wrap_stretch_mode_parameters(self): """Wrap the stretch modes implicit to the Molecule as Parameters. @@ -417,7 +735,7 @@ def wrapStretchModeParameters(self): bond lengths: "bl_aname1_aname2" bond angles: "ba_aname1_aname2_aname3" """ - for mode in self.scat.GetStretchModeBondLengthList(): + for mode in self.scatterer.GetStretchModeBondLengthList(): name1 = mode.mpAtom0.GetName() name2 = mode.mpAtom1.GetName() @@ -433,11 +751,11 @@ def wrapStretchModeParameters(self): name = a.GetName() atoms.append(getattr(self, name)) - par.AddAtoms(atoms) + par.add_atoms(atoms) self.add_parameter(par) - for mode in self.scat.GetStretchModeBondAngleList(): + for mode in self.scatterer.GetStretchModeBondAngleList(): name1 = mode.mpAtom0.GetName() name2 = mode.mpAtom1.GetName() name3 = mode.mpAtom2.GetName() @@ -456,13 +774,24 @@ def wrapStretchModeParameters(self): for a in mode.GetAtoms(): name = a.GetName() atoms.append(getattr(self, name)) - par.AddAtoms(atoms) + par.add_atoms(atoms) self.add_parameter(par) return - def restrainBondLength( + @deprecated(molecule_wrapStretchModeParameters_dep_msg) + def wrapStretchModeParameters(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.wrap_stretch_mode_parameters + instead. + """ + return self.wrap_stretch_mode_parameters() + + def restrain_bond_length( self, atom1, atom2, length, sigma, delta, scaled=False ): """Add a bond length restraint. @@ -500,7 +829,22 @@ def restrainBondLength( return res - def restrainBondLengthParameter( + @deprecated(molecule_restrainBondLength_dep_msg) + def restrainBondLength( + self, atom1, atom2, length, sigma, delta, scaled=False + ): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.restrain_bond_length + instead. + """ + return self.restrain_bond_length( + atom1, atom2, length, sigma, delta, scaled + ) + + def restrain_bond_length_parameter( self, par, length, sigma, delta, scaled=False ): """Add a bond length restraint. @@ -511,7 +855,7 @@ def restrainBondLengthParameter( Parameters ---------- par - A ObjCrystBondLengthParameter (see addBondLengthParameter) + A ObjCrystBondLengthParameter (see add_bond_length_parameter) length The length of the bond (Angstroms) sigma @@ -529,11 +873,26 @@ def restrainBondLengthParameter( Returns the ObjCrystBondLengthRestraint object for use with the 'unrestrain' method. """ - return self.restrainBondLength( + return self.restrain_bond_length( par.atom1, par.atom2, length, sigma, delta, scaled ) - def restrainBondAngle( + @deprecated(molecule_restrainBondLengthParameter_dep_msg) + def restrainBondLengthParameter( + self, par, length, sigma, delta, scaled=False + ): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.restrain_bond_length_parameter + instead. + """ + return self.restrain_bond_length_parameter( + par, length, sigma, delta, scaled + ) + + def restrain_bond_angle( self, atom1, atom2, atom3, angle, sigma, delta, scaled=False ): """Add a bond angle restraint. @@ -574,7 +933,22 @@ def restrainBondAngle( return res - def restrainBondAngleParameter( + @deprecated(molecule_restrainBondAngle_dep_msg) + def restrainBondAngle( + self, atom1, atom2, atom3, angle, sigma, delta, scaled=False + ): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.restrain_bond_angle + instead. + """ + return self.restrain_bond_angle( + atom1, atom2, atom3, angle, sigma, delta, scaled + ) + + def restrain_bond_angle_parameter( self, par, angle, sigma, delta, scaled=False ): """Add a bond angle restraint. @@ -585,7 +959,7 @@ def restrainBondAngleParameter( Parameters ---------- par - A ObjCrystBondAngleParameter (see addBondAngleParameter) + A ObjCrystBondAngleParameter (see add_bond_angle_parameter) angle The bond angle (radians) sigma @@ -603,11 +977,26 @@ def restrainBondAngleParameter( Returns the ObjCrystBondAngleRestraint object for use with the 'unrestrain' method. """ - return self.restrainBondAngle( + return self.restrain_bond_angle( par.atom1, par.atom2, par.atom3, angle, sigma, delta, scaled ) - def restrainDihedralAngle( + @deprecated(molecule_restrainBondAngleParameter_dep_msg) + def restrainBondAngleParameter( + self, par, angle, sigma, delta, scaled=False + ): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.restrain_bond_angle_parameter + instead. + """ + return self.restrain_bond_angle_parameter( + par, angle, sigma, delta, scaled + ) + + def restrain_dihedral_angle( self, atom1, atom2, atom3, atom4, angle, sigma, delta, scaled=False ): """Add a dihedral angle restraint. @@ -649,7 +1038,22 @@ def restrainDihedralAngle( return res - def restrainDihedralAngleParameter( + @deprecated(molecule_restrainDihedralAngle_dep_msg) + def restrainDihedralAngle( + self, atom1, atom2, atom3, atom4, angle, sigma, delta, scaled=False + ): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.restrain_dihedral_angle + instead. + """ + return self.restrain_dihedral_angle( + atom1, atom2, atom3, atom4, angle, sigma, delta, scaled + ) + + def restrain_dihedral_angle_parameter( self, par, angle, sigma, delta, scaled=False ): """Add a dihedral angle restraint. @@ -661,7 +1065,7 @@ def restrainDihedralAngleParameter( ---------- par A ObjCrystDihedralAngleParameter (see - addDihedralAngleParameter) + add_dihedral_angle_parameter) angle The dihedral angle (radians) sigma @@ -679,7 +1083,7 @@ def restrainDihedralAngleParameter( Returns the ObjCrystDihedralAngleRestraint object for use with the 'unrestrain' method. """ - return self.restrainDihedralAngle( + return self.restrain_dihedral_angle( par.atom1, par.atom2, par.atom3, @@ -690,7 +1094,22 @@ def restrainDihedralAngleParameter( scaled, ) - def addBondLengthParameter( + @deprecated(molecule_restrainDihedralAngleParameter_dep_msg) + def restrainDihedralAngleParameter( + self, par, angle, sigma, delta, scaled=False + ): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.restrain_dihedral_angle_parameter + instead. + """ + return self.restrain_dihedral_angle_parameter( + par, angle, sigma, delta, scaled + ) + + def add_bond_length_parameter( self, name, atom1, atom2, value=None, const=False ): """Add a bond length to the Molecule. @@ -725,7 +1144,20 @@ def addBondLengthParameter( return par - def addBondAngleParameter( + @deprecated(molecule_addBondLengthParameter_dep_msg) + def addBondLengthParameter( + self, name, atom1, atom2, value=None, const=False + ): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.add_bond_length_parameter + instead. + """ + return self.add_bond_length_parameter(name, atom1, atom2, value, const) + + def add_bond_angle_parameter( self, name, atom1, atom2, atom3, value=None, const=False ): """Add a bond angle to the Molecule. @@ -765,7 +1197,22 @@ def addBondAngleParameter( return par - def addDihedralAngleParameter( + @deprecated(molecule_addBondAngleParameter_dep_msg) + def addBondAngleParameter( + self, name, atom1, atom2, atom3, value=None, const=False + ): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.add_bond_angle_parameter + instead. + """ + return self.add_bond_angle_parameter( + name, atom1, atom2, atom3, value, const + ) + + def add_dihedral_angle_parameter( self, name, atom1, atom2, atom3, atom4, value=None, const=False ): """Add a dihedral angle to the Molecule. @@ -809,6 +1256,21 @@ def addDihedralAngleParameter( return par + @deprecated(molecule_addDihedralAngleParameter_dep_msg) + def addDihedralAngleParameter( + self, name, atom1, atom2, atom3, atom4, value=None, const=False + ): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeParSet.add_dihedral_angle_parameter + instead. + """ + return self.add_dihedral_angle_parameter( + name, atom1, atom2, atom3, atom4, value, const + ) + # End class ObjCrystMoleculeParSet @@ -822,7 +1284,7 @@ class ObjCrystMolAtomParSet(ObjCrystScattererParSet): Attributes ---------- - scat + scatterer The adapted pyobjcryst.molecule.MolAtom. parent The ObjCrystCrystalParSet this belongs to @@ -836,7 +1298,7 @@ class ObjCrystMolAtomParSet(ObjCrystScattererParSet): (ParameterAdapter) Biso Isotropic scattering factor (ParameterAdapter). This does - not exist for dummy atoms. See the 'isDummy' method. + not exist for dummy atoms. See the 'is_dummy' method. B11, B22, B33, B12, B21, B23, B32, B13, B31 -- Anisotropic displacement factor for scatterer (ParameterAdapter or ParameterProxy). Note that the Bij and Bji @@ -881,7 +1343,7 @@ def __init__(self, name, scat, parent): def _getelem(self): """Getter for the element type.""" - sp = self.scat.GetScatteringPower() + sp = self.scatterer.GetScatteringPower() if sp: return sp.GetSymbol() else: @@ -889,9 +1351,9 @@ def _getelem(self): element = property(_getelem) - def isDummy(self): + def is_dummy(self): """Indicate whether this atom is a dummy atom.""" - return self.scat.IsDummy() + return self.scatterer.IsDummy() # End class ObjCrystMolAtomParSet @@ -907,7 +1369,7 @@ class ObjCrystMoleculeRestraint(object): Attributes ---------- - res + restraint The pyobjcryst Molecule restraint. scaled A flag indicating if the restraint is scaled (multiplied) by @@ -915,6 +1377,23 @@ class ObjCrystMoleculeRestraint(object): False). """ + @property + @deprecated(restraint_res_dep_msg) + def res(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystMoleculeRestraint.restraint + instead. + """ + return self.restraint + + @res.setter + @deprecated(restraint_res_dep_msg) + def res(self, value): + self.restraint = value + def __init__(self, res, scaled=False): """Create a Restraint-like from a pyobjcryst Molecule restraint. @@ -927,13 +1406,13 @@ def __init__(self, res, scaled=False): by the unrestrained point-average chi^2 (chi^2/numpoints) (default False). """ - self.res = res + self.restraint = res self.scaled = scaled return def __str__(self): """Return the restrained atoms with the restraint settings.""" - res = self.res + res = self.restraint if hasattr(res, "GetLength0"): target = ( f"length = {res.GetLength0():f}, " @@ -958,7 +1437,7 @@ def penalty(self, w=1.0): The point-average chi^2 which is optionally used to scale the penalty (default 1.0). """ - penalty = self.res.GetLogLikelihood() + penalty = self.restraint.GetLogLikelihood() if self.scaled: penalty *= w return penalty @@ -982,7 +1461,7 @@ class ObjCrystBondLengthRestraint(ObjCrystMoleculeRestraint): The uncertainty of the bond length (Angstroms) delta The width of the bond (Angstroms) - res + restraint The pyobjcryst BondLength restraint scaled A flag indicating if the restraint is scaled (multiplied) by @@ -1013,24 +1492,24 @@ def __init__(self, atom1, atom2, length, sigma, delta, scaled=False): self.atom1 = atom1 self.atom2 = atom2 - m = self.atom1.scat.GetMolecule() - res = m.AddBond(atom1.scat, atom2.scat, length, sigma, delta) + m = self.atom1.scatterer.GetMolecule() + res = m.AddBond(atom1.scatterer, atom2.scatterer, length, sigma, delta) ObjCrystMoleculeRestraint.__init__(self, res, scaled) return # Give access to the parameters of the restraint length = property( - lambda self: self.res.GetLength0(), - lambda self, val: self.res.SetLength0(val), + lambda self: self.restraint.GetLength0(), + lambda self, val: self.restraint.SetLength0(val), ) sigma = property( - lambda self: self.res.GetLengthSigma(), - lambda self, val: self.res.SetLengthSigma(val), + lambda self: self.restraint.GetLengthSigma(), + lambda self, val: self.restraint.SetLengthSigma(val), ) delta = property( - lambda self: self.res.GetLengthDelta(), - lambda self, val: self.res.SetLengthDelta(val), + lambda self: self.restraint.GetLengthDelta(), + lambda self, val: self.restraint.SetLengthDelta(val), ) @@ -1054,7 +1533,7 @@ class ObjCrystBondAngleRestraint(ObjCrystMoleculeRestraint): The uncertainty of the bond angle (radians) delta The width of the bond angle (radians) - res + restraint The pyobjcryst BondAngle restraint scaled A flag indicating if the restraint is scaled (multiplied) by @@ -1089,9 +1568,14 @@ def __init__(self, atom1, atom2, atom3, angle, sigma, delta, scaled=False): self.atom2 = atom2 self.atom3 = atom3 - m = self.atom1.scat.GetMolecule() + m = self.atom1.scatterer.GetMolecule() res = m.AddBondAngle( - atom1.scat, atom2.scat, atom3.scat, angle, sigma, delta + atom1.scatterer, + atom2.scatterer, + atom3.scatterer, + angle, + sigma, + delta, ) ObjCrystMoleculeRestraint.__init__(self, res, scaled) @@ -1099,16 +1583,16 @@ def __init__(self, atom1, atom2, atom3, angle, sigma, delta, scaled=False): # Give access to the parameters of the restraint angle = property( - lambda self: self.res.GetAngle0(), - lambda self, val: self.res.SetAngle0(val), + lambda self: self.restraint.GetAngle0(), + lambda self, val: self.restraint.SetAngle0(val), ) sigma = property( - lambda self: self.res.GetAngleSigma(), - lambda self, val: self.res.SetAngleSigma(val), + lambda self: self.restraint.GetAngleSigma(), + lambda self, val: self.restraint.SetAngleSigma(val), ) delta = property( - lambda self: self.res.GetAngleDelta(), - lambda self, val: self.res.SetAngleDelta(val), + lambda self: self.restraint.GetAngleDelta(), + lambda self, val: self.restraint.SetAngleDelta(val), ) @@ -1134,7 +1618,7 @@ class ObjCrystDihedralAngleRestraint(ObjCrystMoleculeRestraint): The uncertainty of the dihedral angle (radians) delta The width of the dihedral angle (radians) - res + restraint The pyobjcryst DihedralAngle restraint scaled A flag indicating if the restraint is scaled (multiplied) by @@ -1173,9 +1657,15 @@ def __init__( self.atom3 = atom3 self.atom4 = atom4 - m = self.atom1.scat.GetMolecule() + m = self.atom1.scatterer.GetMolecule() res = m.AddDihedralAngle( - atom1.scat, atom2.scat, atom3.scat, atom4.scat, angle, sigma, delta + atom1.scatterer, + atom2.scatterer, + atom3.scatterer, + atom4.scatterer, + angle, + sigma, + delta, ) ObjCrystMoleculeRestraint.__init__(self, res, scaled) @@ -1183,16 +1673,16 @@ def __init__( # Give access to the parameters of the restraint angle = property( - lambda self: self.res.GetAngle0(), - lambda self, val: self.res.SetAngle0(val), + lambda self: self.restraint.GetAngle0(), + lambda self, val: self.restraint.SetAngle0(val), ) sigma = property( - lambda self: self.res.GetAngleSigma(), - lambda self, val: self.res.SetAngleSigma(val), + lambda self: self.restraint.GetAngleSigma(), + lambda self, val: self.restraint.SetAngleSigma(val), ) delta = property( - lambda self: self.res.GetAngleDelta(), - lambda self, val: self.res.SetAngleDelta(val), + lambda self: self.restraint.GetAngleDelta(), + lambda self, val: self.restraint.SetAngleDelta(val), ) @@ -1207,7 +1697,7 @@ class StretchModeParameter(Parameter): Required attributes ------------------- - matoms + mutated_atoms The set of all mutated AtomParSets molecule The ObjCrystMoleculeParSet the atoms belong to @@ -1220,6 +1710,23 @@ class StretchModeParameter(Parameter): value of the parameter (bool, default True). """ + @property + @deprecated(stretch_mode_matoms_dep_msg) + def matoms(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.StretchModeParameter.mutated_atoms + instead. + """ + return self.mutated_atoms + + @matoms.setter + @deprecated(stretch_mode_matoms_dep_msg) + def matoms(self, value): + self.mutated_atoms = value + def __init__(self, name, value=None, const=False): """Initialization. @@ -1256,7 +1763,7 @@ def set_value(self, val): return self - def addAtoms(self, atomlist): + def add_atoms(self, atomlist): """Associate ObjCrystMolAtomParSets with the Parameter. This will associate additional ObjCrystMolAtomParSets with the @@ -1268,7 +1775,7 @@ def addAtoms(self, atomlist): if not hasattr(atomlist, "__iter__"): atomlist = [atomlist] # Record the added atoms in the Parameter - self.matoms.update(atomlist) + self.mutated_atoms.update(atomlist) # Make sure we're observing these atoms for a in atomlist: a.x.add_observer(self._flush) @@ -1276,10 +1783,21 @@ def addAtoms(self, atomlist): a.z.add_observer(self._flush) # Record the added atoms in the StretchMode - scatlist = [a.scat for a in atomlist] + scatlist = [a.scatterer for a in atomlist] self.mode.AddAtoms(scatlist) return self + @deprecated(stretch_mode_addAtoms_dep_msg) + def addAtoms(self, atomlist): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.StretchModeParameter.add_atoms + instead. + """ + return self.add_atoms(atomlist) + def notify(self, other=()): """Notify all mutated Parameters and observers. @@ -1289,7 +1807,7 @@ def notify(self, other=()): """ noneother = () # Notify the atoms that have moved - for a in self.matoms: + for a in self.mutated_atoms: a.x._flush(noneother) a.y._flush(noneother) a.z._flush(noneother) @@ -1339,7 +1857,7 @@ class ObjCrystBondLengthParameter(StretchModeParameter): The first ObjCrystMolAtomParSet in the bond atom2 The second (mutated) ObjCrystMolAtomParSet in the bond - matoms + mutated_atoms The set of all mutated ObjCrystMolAtomParSets molecule The ObjCrystMoleculeParSet the ObjCrystMolAtomParSets @@ -1393,10 +1911,12 @@ def __init__(self, name, atom1, atom2, value=None, const=False, mode=None): # Create the mode self.mode = mode if mode is None: - self.mode = StretchModeBondLength(atom1.scat, atom2.scat, None) + self.mode = StretchModeBondLength( + atom1.scatterer, atom2.scatterer, None + ) # We only add the last atom. This is the one that will move - self.mode.AddAtom(atom2.scat) - self.matoms = set([atom2]) + self.mode.AddAtom(atom2.scatterer) + self.mutated_atoms = set([atom2]) # Observe the atom positions for a in [atom1, atom2]: @@ -1410,7 +1930,7 @@ def __init__(self, name, atom1, atom2, value=None, const=False, mode=None): # We do this last so the atoms are defined before we set any values. if value is None: - value = GetBondLength(atom1.scat, atom2.scat) + value = GetBondLength(atom1.scatterer, atom2.scatterer) StretchModeParameter.__init__(self, name, value, const) self.set_constant(const) @@ -1465,7 +1985,7 @@ def get_value(self): necessary each time this is called. """ if self._value is None: - val = GetBondLength(self.atom1.scat, self.atom2.scat) + val = GetBondLength(self.atom1.scatterer, self.atom2.scatterer) Parameter.set_value(self, val) return self._value @@ -1494,7 +2014,7 @@ class ObjCrystBondAngleParameter(StretchModeParameter): The second (central) ObjCrystMolAtomParSet in the bond angle atom3 The third (mutated) ObjCrystMolAtomParSet in the bond angle - matoms + mutated_atoms The set of all mutated ObjCrystMolAtomParSets molecule The ObjCrystMoleculeParSet the ObjCrystMolAtomParSets @@ -1553,11 +2073,11 @@ def __init__( self.mode = mode if mode is None: self.mode = StretchModeBondAngle( - atom1.scat, atom2.scat, atom3.scat, None + atom1.scatterer, atom2.scatterer, atom3.scatterer, None ) # We only add the last atom. This is the one that will move - self.mode.AddAtom(atom3.scat) - self.matoms = set([atom3]) + self.mode.AddAtom(atom3.scatterer) + self.mutated_atoms = set([atom3]) # Observe the atom positions for a in [atom1, atom2, atom3]: @@ -1572,7 +2092,9 @@ def __init__( # We do this last so the atoms are defined before we set any values. if value is None: - value = GetBondAngle(atom1.scat, atom2.scat, atom3.scat) + value = GetBondAngle( + atom1.scatterer, atom2.scatterer, atom3.scatterer + ) StretchModeParameter.__init__(self, name, value, const) self.set_constant(const) @@ -1627,7 +2149,9 @@ def get_value(self): """ if self._value is None: val = GetBondAngle( - self.atom1.scat, self.atom2.scat, self.atom3.scat + self.atom1.scatterer, + self.atom2.scatterer, + self.atom3.scatterer, ) Parameter.set_value(self, val) @@ -1662,7 +2186,7 @@ class ObjCrystDihedralAngleParameter(StretchModeParameter): atom4 The fourth (mutated) ObjCrystMolAtomParSet in the dihedral angle - matoms + mutated_atoms The set of all mutated ObjCrystMolAtomParSets molecule The ObjCrystMoleculeParSet the atoms belong to @@ -1732,10 +2256,12 @@ def __init__( # Create the stretch mode self.mode = mode if mode is None: - self.mode = StretchModeTorsion(atom2.scat, atom3.scat, None) + self.mode = StretchModeTorsion( + atom2.scatterer, atom3.scatterer, None + ) # We only add the last atom. This is the one that will move - self.mode.AddAtom(atom4.scat) - self.matoms = set([atom4]) + self.mode.AddAtom(atom4.scatterer) + self.mutated_atoms = set([atom4]) # Observe the atom positions for a in [atom1, atom2, atom3, atom4]: @@ -1752,7 +2278,10 @@ def __init__( # We do this last so the atoms are defined before we set any values. if value is None: value = GetDihedralAngle( - atom1.scat, atom2.scat, atom3.scat, atom4.scat + atom1.scatterer, + atom2.scatterer, + atom3.scatterer, + atom4.scatterer, ) StretchModeParameter.__init__(self, name, value, const) self.set_constant(const) @@ -1807,10 +2336,10 @@ def get_value(self): """ if self._value is None: val = GetDihedralAngle( - self.atom1.scat, - self.atom2.scat, - self.atom3.scat, - self.atom4.scat, + self.atom1.scatterer, + self.atom2.scatterer, + self.atom3.scatterer, + self.atom4.scatterer, ) Parameter.set_value(self, val) @@ -1840,7 +2369,7 @@ class ObjCrystCrystalParSet(SrRealParSet): module. sgpars property that creates _sgpars when it is needed. - angunits + angle_units "rad", the units of angle Parameters @@ -1855,6 +2384,23 @@ class ObjCrystCrystalParSet(SrRealParSet): Occupancy of the scatterer on its crystal site (ParameterWraper) """ + @property + @deprecated(crystal_angunits_dep_msg) + def angunits(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.objcrystparset.ObjCrystCrystalParSet.angle_units + instead. + """ + return self.angle_units + + @angunits.setter + @deprecated(crystal_angunits_dep_msg) + def angunits(self, value): + self.angle_units = value + def __init__(self, name, cryst): """Initialize. @@ -1866,7 +2412,7 @@ def __init__(self, name, cryst): An pyobjcryst.Crystal instance. """ SrRealParSet.__init__(self, name) - self.angunits = "rad" + self.angle_units = "rad" self.structure = cryst self._sgpars = None @@ -1984,17 +2530,17 @@ def _create_space_group(sgobjcryst): return sg @classmethod - def canAdapt(self, stru): + def can_adapt(self, stru): """Return whether the structure can be adapted by this class.""" from pyobjcryst.crystal import Crystal return isinstance(stru, Crystal) - def getLattice(self): + def get_lattice(self): """Get the ParameterSet containing the lattice Parameters.""" return self - def getScatterers(self): + def get_scatterers(self): """Get a list of ParameterSets that represents the scatterers. The site positions must be accessible from the list entries via diff --git a/src/diffpy/srfit/structure/sgconstraints.py b/src/diffpy/srfit/structure/sgconstraints.py index d61a782d..297cf582 100644 --- a/src/diffpy/srfit/structure/sgconstraints.py +++ b/src/diffpy/srfit/structure/sgconstraints.py @@ -64,7 +64,7 @@ def constrain_as_space_group( scatterers The scatterer ParameterSets to constrain. If scatterers is None (default), then all scatterers accessible from - phase.getScatterers will be constrained. + phase.get_scatterers will be constrained. constrainlat Flag indicating whether to constrain the lattice (default True). @@ -182,7 +182,7 @@ def _constrain_as_space_group( from diffpy.structure.symmetryutilities import stdUsymbols if scatterers is None: - scatterers = phase.getScatterers() + scatterers = phase.get_scatterers() if adpsymbols is None: adpsymbols = stdUsymbols @@ -203,6 +203,29 @@ def _constrain_as_space_group( # End constrain_as_space_group +base_sg_base = "diffpy.srfit.structure.sgconstraints.BaseSpaceGroupParameters" +base_sg_new_base = "diffpy.cmistructure.sgconstraints.BaseSpaceGroupParameters" + +base_sg_addParameter_dep_msg = build_deprecation_message( + base_sg_base, + "addParameter", + "add_parameter", + removal_version, + new_base=base_sg_new_base, +) + +sg_base = "diffpy.srfit.structure.sgconstraints.SpaceGroupParameters" +sg_new_base = "diffpy.cmistructure.sgconstraints.SpaceGroupParameters" + +sg_sg_dep_msg = build_deprecation_message( + sg_base, + "sg", + "space_group", + removal_version, + new_base=sg_new_base, +) + + class BaseSpaceGroupParameters(RecipeContainer): """Base class for holding space group Parameters. @@ -226,7 +249,7 @@ def __init__(self, name="sgpars"): RecipeContainer.__init__(self, name) return - def addParameter(self, par, check=True): + def add_parameter(self, par, check=True): """Store a Parameter. Parameters @@ -243,6 +266,17 @@ def addParameter(self, par, check=True): RecipeContainer._add_object(self, par, self._parameters, check) return + @deprecated(base_sg_addParameter_dep_msg) + def addParameter(self, par, check=True): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.sgconstraints.BaseSpaceGroupParameters.add_parameter + instead. + """ + return self.add_parameter(par, check) + # End class BaseSpaceGroupParameters @@ -261,7 +295,7 @@ class SpaceGroupParameters(BaseSpaceGroupParameters): "sgpars" phase The constrained BaseStructure object. - sg + space_group The diffpy.structure.spacegroups.SpaceGroup object corresponding to the space group. sgoffset @@ -291,6 +325,23 @@ class SpaceGroupParameters(BaseSpaceGroupParameters): Property that populates _adppars. """ + @property + @deprecated(sg_sg_dep_msg) + def sg(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use + diffpy.cmistructure.sgconstraints.SpaceGroupParameters.space_group + instead. + """ + return self.space_group + + @sg.setter + @deprecated(sg_sg_dep_msg) + def sg(self, value): + self.space_group = value + def __init__( self, phase, @@ -316,7 +367,7 @@ def __init__( scatterers The scatterer ParameterSets to constrain. If scatterers is None, then all scatterers accessible from - phase.getScatterers will be constrained. + phase.get_scatterers will be constrained. constrainlat Flag indicating whether to constrain the lattice. constrainadps @@ -339,7 +390,7 @@ def __init__( self._manage(self._parsets) self.phase = phase - self.sg = sg + self.space_group = sg self.sgoffset = sgoffset self.scatterers = scatterers self.constrainlat = constrainlat @@ -435,7 +486,7 @@ def _clear_constraints(self): # Clear the lattice if self.constrainlat: - lattice = phase.getLattice() + lattice = phase.get_lattice() latpars = [ lattice.a, lattice.b, @@ -474,9 +525,9 @@ def _constrain_lattice(self): return phase = self.phase - sg = self.sg + sg = self.space_group - lattice = phase.getLattice() + lattice = phase.get_lattice() system = sg.crystal_system if not system: system = "Triclinic" @@ -500,7 +551,7 @@ def _constrain_lattice(self): # FIXME - the original parameter will still appear as # constrained. newpar = self.__add_par(par.name, par) - self._latpars.addParameter(newpar) + self._latpars.add_parameter(newpar) return @@ -514,7 +565,7 @@ def _constrain_xyzs(self, positions): """ from diffpy.structure.symmetryutilities import SymmetryConstraints - sg = self.sg + sg = self.space_group sgoffset = self.sgoffset # We do this without ADPs here so we can skip much complication. See @@ -531,7 +582,7 @@ def _constrain_xyzs(self, positions): idx = int(idx) par = scatterers[idx].get(name) newpar = self.__add_par(pname, par) - self._xyzpars.addParameter(newpar) + self._xyzpars.add_parameter(newpar) # Constrain non-free xyz parameters fpos = g.position_formulas(xyznames) @@ -562,7 +613,7 @@ def _constrain_adps(self, positions): if not self.constrainadps: return - sg = self.sg + sg = self.space_group sgoffset = self.sgoffset scatterers = self.scatterers isosymbol = self.isosymbol @@ -616,13 +667,13 @@ def _constrain_adps(self, positions): if par is not None: parname = "%s_%i" % (isosymbol, idx) newpar = self.__add_par(parname, par) - self._adppars.addParameter(newpar) + self._adppars.add_parameter(newpar) isonames.append(newpar.name) else: par = scatterer.get(name) if par is not None: newpar = self.__add_par(pname, par) - self._adppars.addParameter(newpar) + self._adppars.add_parameter(newpar) # Constrain dependent isotropics for idx, isoname in zip(isoidx[:], isonames): @@ -661,7 +712,7 @@ def __add_par(self, parname, par): Index to identify scatterer from which par comes """ newpar = ParameterProxy(parname, par) - self.addParameter(newpar) + self.add_parameter(newpar) return newpar @@ -684,7 +735,7 @@ def _constrain_monoclinic(lattice): gamma, in which case alpha and gamma are constrained to 90. """ afactor = 1 - if lattice.angunits == "rad": + if lattice.angle_units == "rad": afactor = deg2rad ang90 = 90.0 * afactor lattice.alpha.set_constant(True, ang90) @@ -704,7 +755,7 @@ def _constrain_orthorhombic(lattice): alpha, beta and gamma are constrained to 90 """ afactor = 1 - if lattice.angunits == "rad": + if lattice.angle_units == "rad": afactor = deg2rad ang90 = 90.0 * afactor lattice.alpha.set_constant(True, ang90) @@ -720,7 +771,7 @@ def _constrain_tetragonal(lattice): 90. """ afactor = 1 - if lattice.angunits == "rad": + if lattice.angle_units == "rad": afactor = deg2rad ang90 = 90.0 * afactor lattice.alpha.set_constant(True, ang90) @@ -738,7 +789,7 @@ def _constrain_trigonal(lattice): c are constrained to a, beta and gamma are constrained to alpha. """ afactor = 1 - if lattice.angunits == "rad": + if lattice.angle_units == "rad": afactor = deg2rad ang90 = 90.0 * afactor ang120 = 120.0 * afactor @@ -762,7 +813,7 @@ def _constrain_hexagonal(lattice): gamma is constrained to 120. """ afactor = 1 - if lattice.angunits == "rad": + if lattice.angle_units == "rad": afactor = deg2rad ang90 = 90.0 * afactor ang120 = 120.0 * afactor @@ -780,7 +831,7 @@ def _constrain_cubic(lattice): to 90. """ afactor = 1 - if lattice.angunits == "rad": + if lattice.angle_units == "rad": afactor = deg2rad ang90 = 90.0 * afactor lattice.add_constraint(lattice.b, lattice.a) diff --git a/src/diffpy/srfit/structure/srrealparset.py b/src/diffpy/srfit/structure/srrealparset.py index e1051098..8f267da8 100644 --- a/src/diffpy/srfit/structure/srrealparset.py +++ b/src/diffpy/srfit/structure/srrealparset.py @@ -31,6 +31,26 @@ ) +srreal_base = "diffpy.srfit.structure.srrealparset.SrRealParSet" +srreal_new_base = "diffpy.cmistructure.srrealparset.SrRealParSet" + +srreal_useSymmetry_dep_msg = build_deprecation_message( + srreal_base, + "useSymmetry", + "use_symmetry", + removal_version, + new_base=srreal_new_base, +) + +srreal_usingSymmetry_dep_msg = build_deprecation_message( + srreal_base, + "usingSymmetry", + "using_symmetry", + removal_version, + new_base=srreal_new_base, +) + + class SrRealParSet(BaseStructureParSet): """Base class for SrReal-compatible structure adapters. @@ -96,7 +116,7 @@ def restrainBVS(self, sig=1, scaled=False): """ return self.restrain_bvs(sig, scaled) - def useSymmetry(self, use=True): + def use_symmetry(self, use=True): """Set this structure to use symmetry. This determines how the structure is treated by SrReal @@ -105,10 +125,30 @@ def useSymmetry(self, use=True): self._usesymmetry = bool(use) return - def usingSymmetry(self): + @deprecated(srreal_useSymmetry_dep_msg) + def useSymmetry(self, use=True): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use diffpy.cmistructure.srrealparset.SrRealParSet.use_symmetry + instead. + """ + return self.use_symmetry(use) + + def using_symmetry(self): """Check if symmetry is being used.""" return self._usesymmetry + @deprecated(srreal_usingSymmetry_dep_msg) + def usingSymmetry(self): + """This function has been deprecated and will be removed in version + 4.0.0. + + Please use diffpy.cmistructure.srrealparset.SrRealParSet.using_symmetry + instead. + """ + return self.using_symmetry() + def _get_srreal_structure(self): """Get the structure object for use with SrReal calculators. diff --git a/tests/deprecated/test_pdf_deprecations.py b/tests/deprecated/test_pdf_deprecations.py index 08d5f896..16f4e01d 100644 --- a/tests/deprecated/test_pdf_deprecations.py +++ b/tests/deprecated/test_pdf_deprecations.py @@ -196,7 +196,7 @@ def test_setStructure( actual_structure = generator.stru expected_structure = nacl_structure assert actual_structure == expected_structure - actual_periodic = generator.phase.usingSymmetry() + actual_periodic = generator.phase.using_symmetry() assert actual_periodic == expected_periodic @@ -246,7 +246,7 @@ def test_setPhase( actual_phase = generator.phase expected_phase = parameter_set assert actual_phase == expected_phase - actual_periodic = generator.phase.usingSymmetry() + actual_periodic = generator.phase.using_symmetry() assert actual_periodic == expected_periodic diff --git a/tests/deprecated/test_structure_deprecations.py b/tests/deprecated/test_structure_deprecations.py index dac4c899..4dd2e479 100644 --- a/tests/deprecated/test_structure_deprecations.py +++ b/tests/deprecated/test_structure_deprecations.py @@ -5,12 +5,16 @@ """ import importlib +from types import SimpleNamespace import pytest import diffpy.srfit.structure -from diffpy.srfit.structure import struToParameterSet +from diffpy.srfit.fitbase.parameter import Parameter +from diffpy.srfit.structure import constrain_as_space_group, struToParameterSet +from diffpy.srfit.structure.cctbxparset import CCTBXScattererParSet from diffpy.srfit.structure.diffpyparset import DiffpyStructureParSet +from diffpy.srfit.structure.sgconstraints import BaseSpaceGroupParameters from diffpy.structure import Atom, Lattice, Structure @@ -21,6 +25,37 @@ def nacl_structure(): return Structure(atoms, lattice=lattice) +class CCTBXStructureStandIn: + """Stand in for a cctbx structure that holds one scatterer.""" + + def __init__(self): + self._scatterers = [ + SimpleNamespace(site=(0.0, 0.0, 0.0), occupancy=1.0, u_iso=0.01) + ] + + def scatterers(self): + return self._scatterers + + +def make_crystal_parameter_set(): + """Make an ObjCrystCrystalParSet holding a four-atom molecule.""" + from pyobjcryst.crystal import Crystal + from pyobjcryst.molecule import Molecule + from pyobjcryst.scatteringpower import ScatteringPowerAtom + + from diffpy.srfit.structure.objcrystparset import ObjCrystCrystalParSet + + crystal = Crystal(10, 10, 10, "P1") + molecule = Molecule(crystal, "molecule") + crystal.AddScatterer(molecule) + scattering_power = ScatteringPowerAtom("C", "C") + atom_positions = [(0, 0, 0), (1.5, 0, 0), (1.5, 1.5, 0), (1.5, 1.5, 1.5)] + for index, (x, y, z) in enumerate(atom_positions): + molecule.AddAtom(x, y, z, scattering_power, f"C{index}") + crystal_parameter_set = ObjCrystCrystalParSet("crystal", crystal) + return crystal_parameter_set + + def test_structure_package_import_warns(): # Case: diffpy.srfit.structure is imported. # Expected: A DeprecationWarning points to diffpy.cmistructure. @@ -115,3 +150,764 @@ def test_stru_set(nacl_structure): actual_structure = parameter_set.structure expected_structure = nacl_structure assert actual_structure == expected_structure + + +@pytest.mark.parametrize( + "old_name, new_name, expected_msg", + [ + # Test the deprecated getters of the structure parameter sets. + # C1: getLattice is called on a DiffpyStructureParSet. + # Expected: Warns that get_lattice in diffpy.cmistructure replaces + # it, and returns the same lattice as get_lattice. + ( + "getLattice", + "get_lattice", + "'diffpy.srfit.structure.basestructureparset.BaseStructureParSet." + "getLattice' is deprecated and will be removed in version 4.0.0. " + "Please use 'diffpy.cmistructure.basestructureparset." + "BaseStructureParSet.get_lattice' instead.", + ), + # C2: getScatterers is called on a DiffpyStructureParSet. + # Expected: Warns that get_scatterers in diffpy.cmistructure + # replaces it, and returns the same scatterers as get_scatterers. + ( + "getScatterers", + "get_scatterers", + "'diffpy.srfit.structure.basestructureparset.BaseStructureParSet." + "getScatterers' is deprecated and will be removed in version " + "4.0.0. Please use 'diffpy.cmistructure.basestructureparset." + "BaseStructureParSet.get_scatterers' instead.", + ), + # C3: usingSymmetry is called on a DiffpyStructureParSet. + # Expected: Warns that using_symmetry in diffpy.cmistructure + # replaces it, and returns the same flag as using_symmetry. + ( + "usingSymmetry", + "using_symmetry", + "'diffpy.srfit.structure.srrealparset.SrRealParSet.usingSymmetry' " + "is deprecated and will be removed in version 4.0.0. Please use " + "'diffpy.cmistructure.srrealparset.SrRealParSet.using_symmetry' " + "instead.", + ), + ], +) +def test_structure_parameter_set_getters( + nacl_structure, old_name, new_name, expected_msg +): + parameter_set = DiffpyStructureParSet("nacl", nacl_structure) + with pytest.warns(DeprecationWarning) as record: + actual_result = getattr(parameter_set, old_name)() + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_result = getattr(parameter_set, new_name)() + assert actual_result == expected_result + + +def test_canAdapt(nacl_structure): + # Case: canAdapt is called on DiffpyStructureParSet with a diffpy + # Structure. + # Expected: A DeprecationWarning points to can_adapt in + # diffpy.cmistructure, and True is returned. + expected_msg = ( + "'diffpy.srfit.structure.basestructureparset.BaseStructureParSet." + "canAdapt' is deprecated and will be removed in version 4.0.0. " + "Please use 'diffpy.cmistructure.basestructureparset." + "BaseStructureParSet.can_adapt' instead." + ) + with pytest.warns(DeprecationWarning) as record: + actual_result = DiffpyStructureParSet.canAdapt(nacl_structure) + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_result = True + assert actual_result == expected_result + + +def test_useSymmetry(nacl_structure): + # Case: useSymmetry(False) is called on a DiffpyStructureParSet. + # Expected: A DeprecationWarning points to use_symmetry in + # diffpy.cmistructure, and using_symmetry returns False. + parameter_set = DiffpyStructureParSet("nacl", nacl_structure) + expected_msg = ( + "'diffpy.srfit.structure.srrealparset.SrRealParSet.useSymmetry' is " + "deprecated and will be removed in version 4.0.0. Please use " + "'diffpy.cmistructure.srrealparset.SrRealParSet.use_symmetry' " + "instead." + ) + with pytest.warns(DeprecationWarning) as record: + parameter_set.useSymmetry(False) + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + actual_using_symmetry = parameter_set.using_symmetry() + expected_using_symmetry = False + assert actual_using_symmetry == expected_using_symmetry + + +def test_angunits_diffpy_lattice(nacl_structure): + # Case: .angunits is read and then set on a DiffpyLatticeParSet. + # Expected: Both warn that .angle_units in diffpy.cmistructure + # replaces it. The read returns "deg", and the set updates + # .angle_units. + lattice = DiffpyStructureParSet("nacl", nacl_structure).lattice + expected_msg = ( + "'diffpy.srfit.structure.diffpyparset.DiffpyLatticeParSet.angunits' " + "is deprecated and will be removed in version 4.0.0. Please use " + "'diffpy.cmistructure.diffpyparset.DiffpyLatticeParSet.angle_units' " + "instead." + ) + with pytest.warns(DeprecationWarning) as record: + actual_angle_units = lattice.angunits + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_angle_units = "deg" + assert actual_angle_units == expected_angle_units + with pytest.warns(DeprecationWarning) as record: + lattice.angunits = "rad" + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + actual_angle_units = lattice.angle_units + expected_angle_units = "rad" + assert actual_angle_units == expected_angle_units + + +def test_sg(nacl_structure): + # Case: .sg is read and then set on SpaceGroupParameters. + # Expected: Both warn that .space_group in diffpy.cmistructure + # replaces it. The read returns the space group the parameters were + # made with, and the set updates .space_group. + parameter_set = DiffpyStructureParSet("nacl", nacl_structure) + space_group_parameters = constrain_as_space_group(parameter_set, "Fm-3m") + expected_msg = ( + "'diffpy.srfit.structure.sgconstraints.SpaceGroupParameters.sg' is " + "deprecated and will be removed in version 4.0.0. Please use " + "'diffpy.cmistructure.sgconstraints.SpaceGroupParameters." + "space_group' instead." + ) + with pytest.warns(DeprecationWarning) as record: + actual_space_group = space_group_parameters.sg + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_space_group = space_group_parameters.space_group + assert actual_space_group == expected_space_group + with pytest.warns(DeprecationWarning) as record: + space_group_parameters.sg = "P1" + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + actual_space_group = space_group_parameters.space_group + expected_space_group = "P1" + assert actual_space_group == expected_space_group + + +def test_addParameter(): + # Case: addParameter stores a Parameter in BaseSpaceGroupParameters. + # Expected: A DeprecationWarning points to add_parameter in + # diffpy.cmistructure, and the Parameter is stored. + space_group_parameters = BaseSpaceGroupParameters() + parameter = Parameter("a", 4.0) + expected_msg = ( + "'diffpy.srfit.structure.sgconstraints.BaseSpaceGroupParameters." + "addParameter' is deprecated and will be removed in version 4.0.0. " + "Please use 'diffpy.cmistructure.sgconstraints." + "BaseSpaceGroupParameters.add_parameter' instead." + ) + with pytest.warns(DeprecationWarning) as record: + space_group_parameters.addParameter(parameter) + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + actual_parameter = space_group_parameters.a + expected_parameter = parameter + assert actual_parameter == expected_parameter + + +@pytest.mark.parametrize( + "old_name, new_name, input_value, expected_msg", + [ + # Test the deprecated attributes of CCTBXScattererParSet. + # C1: .strups is read and then set. + # Expected: Both warn that .structure_parameter_set in + # diffpy.cmistructure replaces it, and they read and set the same + # value as .structure_parameter_set. + ( + "strups", + "structure_parameter_set", + "new crystal", + "'diffpy.srfit.structure.cctbxparset.CCTBXScattererParSet." + "strups' is deprecated and will be removed in version 4.0.0. " + "Please use 'diffpy.cmistructure.cctbxparset." + "CCTBXScattererParSet.structure_parameter_set' instead.", + ), + # C2: .idx is read and then set. + # Expected: Both warn that .index in diffpy.cmistructure replaces + # it, and they read and set the same value as .index. + ( + "idx", + "index", + 3, + "'diffpy.srfit.structure.cctbxparset.CCTBXScattererParSet.idx' " + "is deprecated and will be removed in version 4.0.0. Please use " + "'diffpy.cmistructure.cctbxparset.CCTBXScattererParSet.index' " + "instead.", + ), + ], +) +def test_cctbx_scatterer_attributes( + old_name, new_name, input_value, expected_msg +): + crystal = SimpleNamespace(structure=CCTBXStructureStandIn()) + scatterer = CCTBXScattererParSet("atom", crystal, 0) + with pytest.warns(DeprecationWarning) as record: + actual_value = getattr(scatterer, old_name) + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_value = getattr(scatterer, new_name) + assert actual_value == expected_value + with pytest.warns(DeprecationWarning) as record: + setattr(scatterer, old_name, input_value) + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + actual_value = getattr(scatterer, new_name) + expected_value = input_value + assert actual_value == expected_value + + +@pytest.mark.parametrize( + "old_name, new_name, input_args, expected_msg", + [ + # Test the deprecated methods of ObjCrystMoleculeParSet that + # return a value or change nothing. + # C1: getScatterers is called. + # Expected: Warns that get_scatterers in diffpy.cmistructure + # replaces it, and returns the same atoms as get_scatterers. + ( + "getScatterers", + "get_scatterers", + (), + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "getScatterers' is deprecated and will be removed in version " + "4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.get_scatterers' instead.", + ), + # C2: usingSymmetry is called. + # Expected: Warns that using_symmetry in diffpy.cmistructure + # replaces it, and returns False, as using_symmetry does. + ( + "usingSymmetry", + "using_symmetry", + (), + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "usingSymmetry' is deprecated and will be removed in version " + "4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.using_symmetry' instead.", + ), + # C3: useSymmetry(False) is called. + # Expected: Warns that use_symmetry in diffpy.cmistructure + # replaces it, and returns None, as use_symmetry does. + ( + "useSymmetry", + "use_symmetry", + (False,), + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "useSymmetry' is deprecated and will be removed in version " + "4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.use_symmetry' instead.", + ), + # C4: hasScatterers is called. + # Expected: Warns that has_scatterers in diffpy.cmistructure + # replaces it, and returns True, as has_scatterers does. + ( + "hasScatterers", + "has_scatterers", + (), + "'diffpy.srfit.structure.objcrystparset.ObjCrystScattererParSet." + "hasScatterers' is deprecated and will be removed in version " + "4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystScattererParSet.has_scatterers' instead.", + ), + # C5: isDummy is called. + # Expected: Warns that is_dummy in diffpy.cmistructure replaces it, + # and returns False, as is_dummy does. + ( + "isDummy", + "is_dummy", + (), + "'diffpy.srfit.structure.objcrystparset.ObjCrystScattererParSet." + "isDummy' is deprecated and will be removed in version 4.0.0. " + "Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystScattererParSet.is_dummy' instead.", + ), + # C6: wrapRestraints is called on a molecule without restraints. + # Expected: Warns that wrap_restraints in diffpy.cmistructure + # replaces it, and returns None, as wrap_restraints does. + ( + "wrapRestraints", + "wrap_restraints", + (), + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "wrapRestraints' is deprecated and will be removed in version " + "4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.wrap_restraints' instead.", + ), + # C7: wrapStretchModeParameters is called on a molecule without + # stretch modes. + # Expected: Warns that wrap_stretch_mode_parameters in + # diffpy.cmistructure replaces it, and returns None, as + # wrap_stretch_mode_parameters does. + ( + "wrapStretchModeParameters", + "wrap_stretch_mode_parameters", + (), + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "wrapStretchModeParameters' is deprecated and will be removed in " + "version 4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.wrap_stretch_mode_parameters' instead.", + ), + ], +) +def test_molecule_methods( + pyobjcryst_available, old_name, new_name, input_args, expected_msg +): + if not pyobjcryst_available: + pytest.skip("pyobjcryst package not available") + molecule = make_crystal_parameter_set().molecule + with pytest.warns(DeprecationWarning) as record: + actual_result = getattr(molecule, old_name)(*input_args) + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_result = getattr(molecule, new_name)(*input_args) + assert actual_result == expected_result + + +def test_molecule_getLattice(pyobjcryst_available): + # Case: getLattice is called on an ObjCrystMoleculeParSet. + # Expected: A DeprecationWarning points to get_lattice in + # diffpy.cmistructure, and the lattice has the same Parameters as the + # one get_lattice returns. + if not pyobjcryst_available: + pytest.skip("pyobjcryst package not available") + molecule = make_crystal_parameter_set().molecule + expected_msg = ( + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "getLattice' is deprecated and will be removed in version 4.0.0. " + "Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.get_lattice' instead." + ) + with pytest.warns(DeprecationWarning) as record: + actual_lattice = molecule.getLattice() + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_lattice = molecule.get_lattice() + actual_names = actual_lattice.get_names() + expected_names = expected_lattice.get_names() + assert actual_names == expected_names + actual_values = actual_lattice.get_values() + expected_values = expected_lattice.get_values() + assert actual_values == expected_values + + +def test_molecule_canAdapt(pyobjcryst_available): + # Case: canAdapt is called on ObjCrystMoleculeParSet with a pyobjcryst + # Molecule. + # Expected: A DeprecationWarning points to can_adapt in + # diffpy.cmistructure, and True is returned. + if not pyobjcryst_available: + pytest.skip("pyobjcryst package not available") + from diffpy.srfit.structure.objcrystparset import ObjCrystMoleculeParSet + + molecule = make_crystal_parameter_set().molecule + expected_msg = ( + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "canAdapt' is deprecated and will be removed in version 4.0.0. " + "Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.can_adapt' instead." + ) + with pytest.warns(DeprecationWarning) as record: + actual_result = ObjCrystMoleculeParSet.canAdapt(molecule.scatterer) + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_result = True + assert actual_result == expected_result + + +@pytest.mark.parametrize( + "old_name, new_name, atom_count, expected_msg", + [ + # Test the deprecated methods that add stretch-mode Parameters to + # an ObjCrystMoleculeParSet. + # C1: addBondLengthParameter is called with two atoms. + # Expected: Warns that add_bond_length_parameter in + # diffpy.cmistructure replaces it, and the Parameter has the same + # value as one add_bond_length_parameter makes. + ( + "addBondLengthParameter", + "add_bond_length_parameter", + 2, + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "addBondLengthParameter' is deprecated and will be removed in " + "version 4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.add_bond_length_parameter' instead.", + ), + # C2: addBondAngleParameter is called with three atoms. + # Expected: Warns that add_bond_angle_parameter in + # diffpy.cmistructure replaces it, and the Parameter has the same + # value as one add_bond_angle_parameter makes. + ( + "addBondAngleParameter", + "add_bond_angle_parameter", + 3, + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "addBondAngleParameter' is deprecated and will be removed in " + "version 4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.add_bond_angle_parameter' instead.", + ), + # C3: addDihedralAngleParameter is called with four atoms. + # Expected: Warns that add_dihedral_angle_parameter in + # diffpy.cmistructure replaces it, and the Parameter has the same + # value as one add_dihedral_angle_parameter makes. + ( + "addDihedralAngleParameter", + "add_dihedral_angle_parameter", + 4, + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "addDihedralAngleParameter' is deprecated and will be removed in " + "version 4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.add_dihedral_angle_parameter' instead.", + ), + ], +) +def test_molecule_add_parameter_methods( + pyobjcryst_available, old_name, new_name, atom_count, expected_msg +): + if not pyobjcryst_available: + pytest.skip("pyobjcryst package not available") + old_molecule = make_crystal_parameter_set().molecule + new_molecule = make_crystal_parameter_set().molecule + with pytest.warns(DeprecationWarning) as record: + actual_parameter = getattr(old_molecule, old_name)( + "stretch", *old_molecule.atoms[:atom_count] + ) + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_parameter = getattr(new_molecule, new_name)( + "stretch", *new_molecule.atoms[:atom_count] + ) + actual_value = actual_parameter.get_value() + expected_value = expected_parameter.get_value() + assert actual_value == expected_value + + +@pytest.mark.parametrize( + "old_name, new_name, atom_count, target_value, expected_msg", + [ + # Test the deprecated methods that restrain atoms of an + # ObjCrystMoleculeParSet. + # C1: restrainBondLength is called with two atoms. + # Expected: Warns that restrain_bond_length in diffpy.cmistructure + # replaces it, and the restraint has the same penalty as one + # restrain_bond_length makes. + ( + "restrainBondLength", + "restrain_bond_length", + 2, + 1.4, + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "restrainBondLength' is deprecated and will be removed in " + "version 4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.restrain_bond_length' instead.", + ), + # C2: restrainBondAngle is called with three atoms. + # Expected: Warns that restrain_bond_angle in diffpy.cmistructure + # replaces it, and the restraint has the same penalty as one + # restrain_bond_angle makes. + ( + "restrainBondAngle", + "restrain_bond_angle", + 3, + 1.5, + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "restrainBondAngle' is deprecated and will be removed in version " + "4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.restrain_bond_angle' instead.", + ), + # C3: restrainDihedralAngle is called with four atoms. + # Expected: Warns that restrain_dihedral_angle in + # diffpy.cmistructure replaces it, and the restraint has the same + # penalty as one restrain_dihedral_angle makes. + ( + "restrainDihedralAngle", + "restrain_dihedral_angle", + 4, + 1.5, + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "restrainDihedralAngle' is deprecated and will be removed in " + "version 4.0.0. Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystMoleculeParSet.restrain_dihedral_angle' instead.", + ), + ], +) +def test_molecule_restrain_methods( + pyobjcryst_available, + old_name, + new_name, + atom_count, + target_value, + expected_msg, +): + if not pyobjcryst_available: + pytest.skip("pyobjcryst package not available") + old_molecule = make_crystal_parameter_set().molecule + new_molecule = make_crystal_parameter_set().molecule + with pytest.warns(DeprecationWarning) as record: + actual_restraint = getattr(old_molecule, old_name)( + *old_molecule.atoms[:atom_count], target_value, 0.1, 0.1 + ) + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_restraint = getattr(new_molecule, new_name)( + *new_molecule.atoms[:atom_count], target_value, 0.1, 0.1 + ) + actual_penalty = actual_restraint.penalty() + expected_penalty = expected_restraint.penalty() + assert actual_penalty == expected_penalty + + +@pytest.mark.parametrize( + "parameter_adder, old_name, new_name, atom_count, target_value, " + "expected_msg", + [ + # Test the deprecated methods that restrain stretch-mode + # Parameters of an ObjCrystMoleculeParSet. + # C1: restrainBondLengthParameter is called with a bond length + # Parameter. + # Expected: Warns that restrain_bond_length_parameter in + # diffpy.cmistructure replaces it, and the restraint has the same + # penalty as one restrain_bond_length_parameter makes. + ( + "add_bond_length_parameter", + "restrainBondLengthParameter", + "restrain_bond_length_parameter", + 2, + 1.4, + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "restrainBondLengthParameter' is deprecated and will be removed " + "in version 4.0.0. Please use 'diffpy.cmistructure." + "objcrystparset.ObjCrystMoleculeParSet." + "restrain_bond_length_parameter' instead.", + ), + # C2: restrainBondAngleParameter is called with a bond angle + # Parameter. + # Expected: Warns that restrain_bond_angle_parameter in + # diffpy.cmistructure replaces it, and the restraint has the same + # penalty as one restrain_bond_angle_parameter makes. + ( + "add_bond_angle_parameter", + "restrainBondAngleParameter", + "restrain_bond_angle_parameter", + 3, + 1.5, + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "restrainBondAngleParameter' is deprecated and will be removed " + "in version 4.0.0. Please use 'diffpy.cmistructure." + "objcrystparset.ObjCrystMoleculeParSet." + "restrain_bond_angle_parameter' instead.", + ), + # C3: restrainDihedralAngleParameter is called with a dihedral + # angle Parameter. + # Expected: Warns that restrain_dihedral_angle_parameter in + # diffpy.cmistructure replaces it, and the restraint has the same + # penalty as one restrain_dihedral_angle_parameter makes. + ( + "add_dihedral_angle_parameter", + "restrainDihedralAngleParameter", + "restrain_dihedral_angle_parameter", + 4, + 1.5, + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeParSet." + "restrainDihedralAngleParameter' is deprecated and will be " + "removed in version 4.0.0. Please use 'diffpy.cmistructure." + "objcrystparset.ObjCrystMoleculeParSet." + "restrain_dihedral_angle_parameter' instead.", + ), + ], +) +def test_molecule_restrain_parameter_methods( + pyobjcryst_available, + parameter_adder, + old_name, + new_name, + atom_count, + target_value, + expected_msg, +): + if not pyobjcryst_available: + pytest.skip("pyobjcryst package not available") + old_molecule = make_crystal_parameter_set().molecule + new_molecule = make_crystal_parameter_set().molecule + old_parameter = getattr(old_molecule, parameter_adder)( + "stretch", *old_molecule.atoms[:atom_count] + ) + new_parameter = getattr(new_molecule, parameter_adder)( + "stretch", *new_molecule.atoms[:atom_count] + ) + with pytest.warns(DeprecationWarning) as record: + actual_restraint = getattr(old_molecule, old_name)( + old_parameter, target_value, 0.1, 0.1 + ) + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_restraint = getattr(new_molecule, new_name)( + new_parameter, target_value, 0.1, 0.1 + ) + actual_penalty = actual_restraint.penalty() + expected_penalty = expected_restraint.penalty() + assert actual_penalty == expected_penalty + + +def test_addAtoms(pyobjcryst_available): + # Case: addAtoms adds a third atom to a bond length Parameter. + # Expected: A DeprecationWarning points to add_atoms in + # diffpy.cmistructure, and the Parameter mutates the second and third + # atoms. + if not pyobjcryst_available: + pytest.skip("pyobjcryst package not available") + molecule = make_crystal_parameter_set().molecule + parameter = molecule.add_bond_length_parameter( + "bond", molecule.C0, molecule.C1 + ) + expected_msg = ( + "'diffpy.srfit.structure.objcrystparset.StretchModeParameter." + "addAtoms' is deprecated and will be removed in version 4.0.0. " + "Please use 'diffpy.cmistructure.objcrystparset." + "StretchModeParameter.add_atoms' instead." + ) + with pytest.warns(DeprecationWarning) as record: + parameter.addAtoms([molecule.C2]) + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + actual_mutated_atoms = parameter.mutated_atoms + expected_mutated_atoms = {molecule.C1, molecule.C2} + assert actual_mutated_atoms == expected_mutated_atoms + + +def test_angunits_objcryst_crystal(pyobjcryst_available): + # Case: .angunits is read and then set on an ObjCrystCrystalParSet. + # Expected: Both warn that .angle_units in diffpy.cmistructure + # replaces it. The read returns "rad", and the set updates + # .angle_units. + if not pyobjcryst_available: + pytest.skip("pyobjcryst package not available") + crystal = make_crystal_parameter_set() + expected_msg = ( + "'diffpy.srfit.structure.objcrystparset.ObjCrystCrystalParSet." + "angunits' is deprecated and will be removed in version 4.0.0. " + "Please use 'diffpy.cmistructure.objcrystparset." + "ObjCrystCrystalParSet.angle_units' instead." + ) + with pytest.warns(DeprecationWarning) as record: + actual_angle_units = crystal.angunits + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_angle_units = "rad" + assert actual_angle_units == expected_angle_units + with pytest.warns(DeprecationWarning) as record: + crystal.angunits = "deg" + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + actual_angle_units = crystal.angle_units + expected_angle_units = "deg" + assert actual_angle_units == expected_angle_units + + +def test_scat(pyobjcryst_available): + # Case: .scat is read and then set on an ObjCrystMoleculeParSet. + # Expected: Both warn that .scatterer in diffpy.cmistructure replaces + # it. The read returns the adapted pyobjcryst Molecule, and the set + # updates .scatterer. + if not pyobjcryst_available: + pytest.skip("pyobjcryst package not available") + molecule = make_crystal_parameter_set().molecule + expected_msg = ( + "'diffpy.srfit.structure.objcrystparset.ObjCrystScattererParSet." + "scat' is deprecated and will be removed in version 4.0.0. Please " + "use 'diffpy.cmistructure.objcrystparset.ObjCrystScattererParSet." + "scatterer' instead." + ) + with pytest.warns(DeprecationWarning) as record: + actual_scatterer = molecule.scat + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_scatterer = molecule.scatterer + assert actual_scatterer == expected_scatterer + other_scatterer = make_crystal_parameter_set().molecule.scatterer + with pytest.warns(DeprecationWarning) as record: + molecule.scat = other_scatterer + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + actual_scatterer = molecule.scatterer + expected_scatterer = other_scatterer + assert actual_scatterer == expected_scatterer + + +def test_res(pyobjcryst_available): + # Case: .res is read and then set on a bond length restraint. + # Expected: Both warn that .restraint in diffpy.cmistructure replaces + # it. The read returns the wrapped pyobjcryst restraint, and the set + # updates .restraint. + if not pyobjcryst_available: + pytest.skip("pyobjcryst package not available") + molecule = make_crystal_parameter_set().molecule + restraint = molecule.restrain_bond_length( + molecule.C0, molecule.C1, 1.4, 0.1, 0.1 + ) + other_restraint = molecule.restrain_bond_length( + molecule.C1, molecule.C2, 1.4, 0.1, 0.1 + ) + expected_msg = ( + "'diffpy.srfit.structure.objcrystparset.ObjCrystMoleculeRestraint." + "res' is deprecated and will be removed in version 4.0.0. Please use " + "'diffpy.cmistructure.objcrystparset.ObjCrystMoleculeRestraint." + "restraint' instead." + ) + with pytest.warns(DeprecationWarning) as record: + actual_restraint = restraint.res + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_restraint = restraint.restraint + assert actual_restraint == expected_restraint + with pytest.warns(DeprecationWarning) as record: + restraint.res = other_restraint.restraint + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + actual_restraint = restraint.restraint + expected_restraint = other_restraint.restraint + assert actual_restraint == expected_restraint + + +def test_matoms(pyobjcryst_available): + # Case: .matoms is read and then set on a bond length Parameter. + # Expected: Both warn that .mutated_atoms in diffpy.cmistructure + # replaces it. The read returns the mutated atoms, and the set updates + # .mutated_atoms. + if not pyobjcryst_available: + pytest.skip("pyobjcryst package not available") + molecule = make_crystal_parameter_set().molecule + parameter = molecule.add_bond_length_parameter( + "bond", molecule.C0, molecule.C1 + ) + expected_msg = ( + "'diffpy.srfit.structure.objcrystparset.StretchModeParameter." + "matoms' is deprecated and will be removed in version 4.0.0. Please " + "use 'diffpy.cmistructure.objcrystparset.StretchModeParameter." + "mutated_atoms' instead." + ) + with pytest.warns(DeprecationWarning) as record: + actual_mutated_atoms = parameter.matoms + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + expected_mutated_atoms = {molecule.C1} + assert actual_mutated_atoms == expected_mutated_atoms + with pytest.warns(DeprecationWarning) as record: + parameter.matoms = {molecule.C1, molecule.C2} + actual_msg = str(record[0].message) + assert actual_msg == expected_msg + actual_mutated_atoms = parameter.mutated_atoms + expected_mutated_atoms = {molecule.C1, molecule.C2} + assert actual_mutated_atoms == expected_mutated_atoms diff --git a/tests/test_diffpyparset.py b/tests/test_diffpyparset.py index bb532b0b..ad6f808f 100644 --- a/tests/test_diffpyparset.py +++ b/tests/test_diffpyparset.py @@ -142,7 +142,7 @@ def test_show_bvs_restraint(capturestdout, diffpy_srreal_available): parameter_set = DiffpyStructureParSet( "nacl", Structure(atoms, lattice=lattice) ) - parameter_set.restrainBVS(sig=0.5, scaled=True) + parameter_set.restrain_bvs(sig=0.5, scaled=True) lines = capturestdout(parameter_set.show).splitlines() actual_restraint_lines = lines[lines.index("Restraints") + 2 :] expected_restraint_lines = ["BVS of nacl: sig = 0.500000, scaled = True"] diff --git a/tests/test_objcrystparset.py b/tests/test_objcrystparset.py index 0bc2005f..88e7ae09 100644 --- a/tests/test_objcrystparset.py +++ b/tests/test_objcrystparset.py @@ -148,7 +148,7 @@ def testImplicitBondAngleRestraints(self): # make our crystal cryst = ObjCrystCrystalParSet("bucky", occryst) m = cryst.c60 - m.wrapRestraints() + m.wrap_restraints() # make sure that we have some restraints in the molecule assert 2 == len(m._restraints) @@ -232,6 +232,22 @@ def _testMolecule(): _testMolecule() return + def test_get_lattice_of_molecule(self): + # Case: get_lattice is called on an ObjCrystMoleculeParSet. + # Expected: A cubic placeholder lattice with unit cell lengths of + # 1 and angles of 90 degrees is returned. + molecule = ObjCrystCrystalParSet("bucky", self.occryst).c60 + lattice = molecule.get_lattice() + actual_names = lattice.get_names() + expected_names = ["a", "b", "c", "alpha", "beta", "gamma"] + assert actual_names == expected_names + actual_values = lattice.get_values() + expected_values = [1.0, 1.0, 1.0, 90, 90, 90] + assert actual_values == expected_values + actual_angle_units = lattice.angle_units + expected_angle_units = "deg" + assert actual_angle_units == expected_angle_units + def testImplicitBondLengthRestraints(self): """Test the structure with implicit bond lengths.""" occryst = self.occryst @@ -244,7 +260,7 @@ def testImplicitBondLengthRestraints(self): # make our crystal cryst = ObjCrystCrystalParSet("bucky", occryst) m = cryst.c60 - m.wrapRestraints() + m.wrap_restraints() # make sure that we have some restraints in the molecule assert 2 == len(m._restraints) @@ -274,7 +290,7 @@ def testImplicitDihedralAngleRestraints(self): # make our crystal cryst = ObjCrystCrystalParSet("bucky", occryst) m = cryst.c60 - m.wrapRestraints() + m.wrap_restraints() # make sure that we have some restraints in the molecule assert 2 == len(m._restraints) @@ -288,10 +304,34 @@ def testImplicitDihedralAngleRestraints(self): return - def testImplicitStretchModes(self): - """Test the molecule with implicit stretch modes.""" - # Not sure how to make this happen. - pass + def test_wrap_stretch_mode_parameters(self): + # Case: The molecule has two bond lengths and one bond angle in the + # chain C0-C1-C2, and its stretch modes are built. + # Expected: Each bond length and bond angle stretch mode is wrapped + # as a Parameter named after its atoms. pyobjcryst builds one mode + # for each side of a bond or angle, so every name appears in both + # atom orders. + ocmol = self.ocmol + ocmol.AddBond(ocmol[0], ocmol[1], 1.37, 0.1, 0.1) + ocmol.AddBond(ocmol[1], ocmol[2], 6.9, 0.1, 0.1) + ocmol.AddBondAngle(ocmol[0], ocmol[1], ocmol[2], 1.57, 0.1, 0.1) + ocmol.BuildStretchModeBondLength() + ocmol.BuildStretchModeBondAngle() + molecule = ObjCrystCrystalParSet("bucky", self.occryst).c60 + parameter_names_before = set(molecule._parameters) + molecule.wrap_stretch_mode_parameters() + actual_names = sorted( + set(molecule._parameters) - parameter_names_before + ) + expected_names = [ + "ba_C0_C1_C2", + "ba_C2_C1_C0", + "bl_C0_C1", + "bl_C1_C0", + "bl_C1_C2", + "bl_C2_C1", + ] + assert actual_names == expected_names def testExplicitBondLengthRestraints(self): """Test the structure with explicit bond lengths.""" @@ -303,8 +343,8 @@ def testExplicitBondLengthRestraints(self): m = cryst.c60 # make some bond angle restraints - res0 = m.restrainBondLength(m.atoms[0], m.atoms[5], 3.3, 0.1, 0.1) - res1 = m.restrainBondLength(m.atoms[0], m.atoms[7], 3.3, 0.1, 0.1) + res0 = m.restrain_bond_length(m.atoms[0], m.atoms[5], 3.3, 0.1, 0.1) + res1 = m.restrain_bond_length(m.atoms[0], m.atoms[7], 3.3, 0.1, 0.1) # make sure that we have some restraints in the molecule assert 2 == len(m._restraints) @@ -326,9 +366,11 @@ def test_show_explicit_molecule_restraints(self, capturestdout): cryst = ObjCrystCrystalParSet("bucky", self.occryst) molecule = cryst.c60 atoms = molecule.atoms - molecule.restrainBondLength(atoms[0], atoms[5], 3.3, 0.1, 0.2) - molecule.restrainBondAngle(atoms[0], atoms[5], atoms[7], 1.0, 0.1, 0.2) - molecule.restrainDihedralAngle( + molecule.restrain_bond_length(atoms[0], atoms[5], 3.3, 0.1, 0.2) + molecule.restrain_bond_angle( + atoms[0], atoms[5], atoms[7], 1.0, 0.1, 0.2 + ) + molecule.restrain_dihedral_angle( atoms[0], atoms[5], atoms[7], atoms[8], 2.0, 0.1, 0.2 ) lines = capturestdout(cryst.show, textwidth=0).splitlines() @@ -356,7 +398,7 @@ def test_show_implicit_molecule_restraints(self, capturestdout): ocmol[0], ocmol[5], ocmol[7], ocmol[8], 2.0, 0.1, 0.2 ) cryst = ObjCrystCrystalParSet("bucky", self.occryst) - cryst.c60.wrapRestraints() + cryst.c60.wrap_restraints() lines = capturestdout(cryst.show, textwidth=0).splitlines() actual_restraint_lines = set(lines[lines.index("Restraints") + 2 :]) expected_restraint_lines = { @@ -383,10 +425,10 @@ def testExplicitBondAngleRestraints(self): m = cryst.c60 # restrain some bond angles - res0 = m.restrainBondAngle( + res0 = m.restrain_bond_angle( m.atoms[0], m.atoms[5], m.atoms[8], 3.3, 0.1, 0.1 ) - res1 = m.restrainBondAngle( + res1 = m.restrain_bond_angle( m.atoms[0], m.atoms[7], m.atoms[44], 3.3, 0.1, 0.1 ) @@ -411,10 +453,10 @@ def testExplicitDihedralAngleRestraints(self): m = cryst.c60 # Restrain some dihedral angles. - res0 = m.restrainDihedralAngle( + res0 = m.restrain_dihedral_angle( m.atoms[0], m.atoms[5], m.atoms[8], m.atoms[41], 1.1, 0.1, 0.1 ) - res1 = m.restrainDihedralAngle( + res1 = m.restrain_dihedral_angle( m.atoms[0], m.atoms[7], m.atoms[44], m.atoms[2], 1.1, 0.1, 0.1 ) @@ -442,9 +484,9 @@ def testExplicitBondLengthParameter(self): a20 = m.atoms[20] # Add a parameter - p1 = m.addBondLengthParameter("C07", a0, a7) + p1 = m.add_bond_length_parameter("C07", a0, a7) # Have another atom tag along for the ride - p1.addAtoms([a20]) + p1.add_atoms([a20]) xyz0 = numpy.array( [a0.x.get_value(), a0.y.get_value(), a0.z.get_value()] @@ -533,9 +575,9 @@ def testExplicitBondAngleParameter(self): angle0 = numpy.arccos(numpy.dot(v1, v2) / (d1 * d2)) # Add a parameter - p1 = m.addBondAngleParameter("C0720", a0, a7, a20) + p1 = m.add_bond_angle_parameter("C0720", a0, a7, a20) # Have another atom tag along for the ride - p1.addAtoms([a25]) + p1.add_atoms([a25]) assert angle0 == pytest.approx(p1.get_value(), abs=1e-6) @@ -618,9 +660,9 @@ def testExplicitDihedralAngleParameter(self): angle0 = -numpy.arccos(numpy.dot(v123, v234) / (d123 * d234)) # Add a parameter - p1 = m.addDihedralAngleParameter("C072025", a0, a7, a20, a25) + p1 = m.add_dihedral_angle_parameter("C072025", a0, a7, a20, a25) # Have another atom tag along for the ride - p1.addAtoms([a33]) + p1.add_atoms([a33]) assert angle0 == pytest.approx(p1.get_value(), abs=1e-6) diff --git a/tests/test_sgconstraints.py b/tests/test_sgconstraints.py index b4a6aa6f..6cb5b693 100644 --- a/tests/test_sgconstraints.py +++ b/tests/test_sgconstraints.py @@ -47,7 +47,7 @@ def test_ObjCryst_constrain_space_group(pyobjcryst_available): stru.sgpars.adppars # Check the orthorhombic lattice - lattice = stru.getLattice() + lattice = stru.get_lattice() assert lattice.alpha.const assert lattice.beta.const assert lattice.gamma.const @@ -61,7 +61,7 @@ def test_ObjCryst_constrain_space_group(pyobjcryst_available): assert 0 == len(lattice._constraints) # Now make sure the scatterers are constrained properly - scatterers = stru.getScatterers() + scatterers = stru.get_scatterers() la = scatterers[0] assert not la.x.const assert not la.y.const @@ -120,7 +120,7 @@ def test_DiffPy_constrain_as_space_group(datafile, pyobjcryst_available): sgpars = constrain_as_space_group( parset, "P b n m", - scatterers=parset.getScatterers()[::2], + scatterers=parset.get_scatterers()[::2], constrainadps=True, ) @@ -130,7 +130,7 @@ def test_DiffPy_constrain_as_space_group(datafile, pyobjcryst_available): assert par.get_value() is not None # Test the unconstrained atoms - for scatterer in parset.getScatterers()[1::2]: + for scatterer in parset.get_scatterers()[1::2]: assert not scatterer.x.const assert not scatterer.y.const assert not scatterer.z.const @@ -156,7 +156,7 @@ def _proxytest(par): def _alltests(par): return _consttest(par) or _constrainedtest(par) or _proxytest(par) - for idx, scatterer in enumerate(parset.getScatterers()[::2]): + for idx, scatterer in enumerate(parset.get_scatterers()[::2]): # Under this scheme, atom 6 is free to vary test = False for par in [scatterer.x, scatterer.y, scatterer.z]: