def struToParameterSet(name, stru): """Creates a ParameterSet from an structure. This returns a ParameterSet adapted for the structure depending on its type. stru -- a structure object known by this module name -- A name to give the structure. Raises TypeError if stru cannot be adapted """ from diffpy.srfit.structure.diffpyparset import DiffpyStructureParSet if DiffpyStructureParSet.canAdapt(stru): return DiffpyStructureParSet(name, stru) from diffpy.srfit.structure.objcrystparset import ObjCrystCrystalParSet if ObjCrystCrystalParSet.canAdapt(stru): return ObjCrystCrystalParSet(name, stru) from diffpy.srfit.structure.objcrystparset import ObjCrystMoleculeParSet if ObjCrystMoleculeParSet.canAdapt(stru): return ObjCrystMoleculeParSet(name, stru) from diffpy.srfit.structure.cctbxparset import CCTBXCrystalParSet if CCTBXCrystalParSet.canAdapt(stru): return CCTBXCrystalParSet(name, stru) raise TypeError("Unadaptable structure format")
def test_DiffPy_constrainAsSpaceGroup(self): """Test the constrainAsSpaceGroup function.""" from diffpy.srfit.structure.diffpyparset import DiffpyStructureParSet from diffpy.srfit.structure.sgconstraints import constrainAsSpaceGroup stru = makeLaMnO3_P1() parset = DiffpyStructureParSet("LaMnO3", stru) sgpars = constrainAsSpaceGroup(parset, "P b n m", scatterers = parset.getScatterers()[::2], constrainadps = True) # Make sure that the new parameters were created for par in sgpars: self.assertNotEqual(None, par) self.assertNotEqual(None, par.getValue() ) # Test the unconstrained atoms for scatterer in parset.getScatterers()[1::2]: self.assertFalse(scatterer.x.const) self.assertFalse(scatterer.y.const) self.assertFalse(scatterer.z.const) self.assertFalse(scatterer.U11.const) self.assertFalse(scatterer.U22.const) self.assertFalse(scatterer.U33.const) self.assertFalse(scatterer.U12.const) self.assertFalse(scatterer.U13.const) self.assertFalse(scatterer.U23.const) self.assertEqual(0, len(scatterer._constraints)) proxied = [p.par for p in sgpars] def _consttest(par): return par.const def _constrainedtest(par): return par.constrained def _proxytest(par): return par in proxied def _alltests(par): return _consttest(par) or _constrainedtest(par) or _proxytest(par) for idx, scatterer in enumerate(parset.getScatterers()[::2]): # Under this scheme, atom 6 is free to vary test = False for par in [scatterer.x, scatterer.y, scatterer.z]: test |= _alltests(par) self.assertTrue(test) test = False for par in [scatterer.U11, scatterer.U22, scatterer.U33, scatterer.U12, scatterer.U13, scatterer.U23]: test |= _alltests(par) self.assertTrue(test) return
def testConstrainAsSpaceGroup(self): """Test the constrainAsSpaceGroup function.""" from diffpy.srfit.structure.sgconstraints import constrainAsSpaceGroup stru = makeLaMnO3_P1() parset = DiffpyStructureParSet("LaMnO3", stru) sgpars = constrainAsSpaceGroup(parset, "P b n m", scatterers = parset.getScatterers()[::2], constrainadps = True) # Make sure that the new parameters were created for par in sgpars: self.assertNotEquals(None, par) self.assertNotEquals(None, par.getValue() ) # Test the unconstrained atoms for scatterer in parset.getScatterers()[1::2]: self.assertFalse(scatterer.x.const) self.assertFalse(scatterer.y.const) self.assertFalse(scatterer.z.const) self.assertFalse(scatterer.U11.const) self.assertFalse(scatterer.U22.const) self.assertFalse(scatterer.U33.const) self.assertFalse(scatterer.U12.const) self.assertFalse(scatterer.U13.const) self.assertFalse(scatterer.U23.const) self.assertEquals(0, len(scatterer._constraints)) proxied = [p.par for p in sgpars] def _consttest(par): return par.const def _constrainedtest(par): return par.constrained def _proxytest(par): return par in proxied def _alltests(par): return _consttest(par) or _constrainedtest(par) or _proxytest(par) for idx, scatterer in enumerate(parset.getScatterers()[::2]): # Under this scheme, atom 6 is free to vary test = False for par in [scatterer.x, scatterer.y, scatterer.z]: test |= _alltests(par) self.assertTrue(test) test = False for par in [scatterer.U11, scatterer.U22, scatterer.U33, scatterer.U12, scatterer.U13, scatterer.U23]: test |= _alltests(par) self.assertTrue(test) return
def test_ConstrainAsSpaceGroup_args(self): """Test the arguments processing of constrainAsSpaceGroup function. """ from diffpy.srfit.structure.sgconstraints import constrainAsSpaceGroup from diffpy.Structure.SpaceGroups import GetSpaceGroup stru = makeLaMnO3_P1() parset = DiffpyStructureParSet("LaMnO3", stru) sgpars = constrainAsSpaceGroup(parset, "P b n m") sg = GetSpaceGroup('P b n m') parset2 = DiffpyStructureParSet("LMO", makeLaMnO3_P1()) sgpars2 = constrainAsSpaceGroup(parset2, sg) list(sgpars) list(sgpars2) self.assertEqual(sgpars.names, sgpars2.names) return
def test_pickling(self): """Test pickling of DiffpyStructureParSet. """ stru = Structure([Atom("C", [0, 0.2, 0.5])]) dsps = DiffpyStructureParSet("dsps", stru) data = pickle.dumps(dsps) dsps2 = pickle.loads(data) self.assertEqual(1, len(dsps2.atoms)) self.assertEqual(0.2, dsps2.atoms[0].y.value) return
def test___repr__(self): """Test representation of DiffpyStructureParSet objects. """ lat = Lattice(3, 3, 2, 90, 90, 90) atom = Atom("C", [0, 0.2, 0.5]) stru = Structure([atom], lattice=lat) dsps = DiffpyStructureParSet("dsps", stru) self.assertEqual(repr(stru), repr(dsps)) self.assertEqual(repr(lat), repr(dsps.lattice)) self.assertEqual(repr(atom), repr(dsps.atoms[0])) return
def setStructure(self, strufile): """Set the structure used in the calculation. strufile -- The name of a structure file. A diffpy.Structure.Structure object will be created from the file, and that object will be passed to the 'iofq' function whenever it is called. This will create the refinement Parameters using the DiffpyStructureParSet adapter from diffpy.srfit.structure.diffpyparset. DiffpyStructureParSet is a ParameterSet object that organizes and gives attribute access to Parameters and ParameterSets adapted from a diffpy Structure object. The Parameters embedded in the DiffpyStructureParSet are proxies for attributes of the diffpy.Structure.Structure object that is needed by the 'iofq' function. The Parameters will be accessible by name under the 'phase' attribute of this generator, and are organized hierarchically: phase - lattice (retrieved with 'getLattice') - a - b - c - alpha - beta - gamma - scatterers (retrieved with 'getScatterers') - atom1 (the name depends on the element) - x - y - z - occ - U11 - U22 - U33 - U12 - U13 - U23 - Uiso - etc. The diffpy.Structure.Structure instance is held within the DiffpyStructureParSet as the 'stru' attribute. """ # Load the structure from file from diffpy.Structure import Structure stru = Structure() stru.read(strufile) # Create a ParameterSet designed to interface with # diffpy.Structure.Structure objects that organizes the Parameter # hierarchy. Note that the DiffpyStructureParSet holds a handle to the # loaded structure that we use in the __call__ method below. # # We pass the diffpy.Structure.Structure instance, and give the # DiffpyStructureParSet the name "phase". parset = DiffpyStructureParSet("phase", stru) # Put this ParameterSet in the ProfileGenerator. self.addParameterSet(parset) return
def testDiffpyStructureParSet(self): """Test the structure conversion.""" a1 = Atom("Cu", xyz = numpy.array([.0, .1, .2]), Uisoequiv = 0.003) a2 = Atom("Ag", xyz = numpy.array([.3, .4, .5]), Uisoequiv = 0.002) l = Lattice(2.5, 2.5, 2.5, 90, 90, 90) dsstru = Structure([a1,a2], l) # Structure makes copies a1 = dsstru[0] a2 = dsstru[1] s = DiffpyStructureParSet("CuAg", dsstru) self.assertEquals(s.name, "CuAg") def _testAtoms(): # Check the atoms thoroughly self.assertEquals(a1.element, s.Cu0.element) self.assertEquals(a2.element, s.Ag0.element) self.assertEquals(a1.Uisoequiv, s.Cu0.Uiso.getValue()) self.assertEquals(a2.Uisoequiv, s.Ag0.Uiso.getValue()) self.assertEquals(a1.Bisoequiv, s.Cu0.Biso.getValue()) self.assertEquals(a2.Bisoequiv, s.Ag0.Biso.getValue()) for i in xrange(1,4): for j in xrange(i,4): uijstru = getattr(a1, "U%i%i"%(i,j)) uij = getattr(s.Cu0, "U%i%i"%(i,j)).getValue() uji = getattr(s.Cu0, "U%i%i"%(j,i)).getValue() self.assertEquals(uijstru, uij) self.assertEquals(uijstru, uji) bijstru = getattr(a1, "B%i%i"%(i,j)) bij = getattr(s.Cu0, "B%i%i"%(i,j)).getValue() bji = getattr(s.Cu0, "B%i%i"%(j,i)).getValue() self.assertEquals(bijstru, bij) self.assertEquals(bijstru, bji) self.assertEquals(a1.xyz[0], s.Cu0.x.getValue()) self.assertEquals(a1.xyz[1], s.Cu0.y.getValue()) self.assertEquals(a1.xyz[2], s.Cu0.z.getValue()) return def _testLattice(): # Test the lattice self.assertEquals(dsstru.lattice.a, s.lattice.a.getValue()) self.assertEquals(dsstru.lattice.b, s.lattice.b.getValue()) self.assertEquals(dsstru.lattice.c, s.lattice.c.getValue()) self.assertEquals(dsstru.lattice.alpha, s.lattice.alpha.getValue()) self.assertEquals(dsstru.lattice.beta, s.lattice.beta.getValue()) self.assertEquals(dsstru.lattice.gamma, s.lattice.gamma.getValue()) _testAtoms() _testLattice() # Now change some values from the diffpy Structure a1.xyz[1] = 0.123 a1.U11 = 0.321 a1.B32 = 0.111 dsstru.lattice.setLatPar(a=3.0, gamma=121) _testAtoms() _testLattice() # Now change values from the srfit DiffpyStructureParSet s.Cu0.x.setValue(0.456) s.Cu0.U22.setValue(0.441) s.Cu0.B13.setValue(0.550) d = dsstru.lattice.dist(a1.xyz, a2.xyz) s.lattice.b.setValue(4.6) s.lattice.alpha.setValue(91.3) _testAtoms() _testLattice() # Make sure the distance changed self.assertNotEquals(d, dsstru.lattice.dist(a1.xyz, a2.xyz)) return