Python PdfFit.setpar方法代码示例

# 需要导入模块: from diffpy.pdffit2 import PdfFit [as 别名]
# 或者: from diffpy.pdffit2.PdfFit import setpar [as 别名]
    def calculate(self):
        """do the real calculation
        """
        # clean up old results
        self.rcalc = []
        self.Gcalc = []

        # do the job
        if len(self.owner.strucs) == 0:
            raise ControlConfigError("No structure is given for calculation")

        # make sure parameters are initialized
        self.owner.updateParameters()
        from diffpy.pdffit2 import PdfFit
        server = PdfFit()

        # structure needs to be read before dataset allocation
        for struc in self.owner.strucs:
            server.read_struct_string(struc.writeStr('pdffit'))
            for key,var in struc.constraints.items():
                server.constrain(key.encode('ascii'), var.formula.encode('ascii'))

        # set up dataset
        server.alloc(self.stype, self.qmax, self.qdamp,
                self.rmin, self.rmax, self.rlen)
        server.setvar('qbroad', self.qbroad)
        server.setvar('dscale', self.dscale)

        # phase related variables
        # pair selection applies to current dataset,
        # therefore it has to be done after alloc
        nstrucs = len(self.owner.strucs)
        for phaseidx0, struc in enumerate(self.owner.strucs):
            phaseidx1 = phaseidx0 + 1
            server.setphase(phaseidx1)
            server.setvar('pscale', struc.getvar('pscale'))
            server.setvar('spdiameter', struc.getvar('spdiameter'))
            struc.applyPairSelection(server, phaseidx1)

        # set up parameters
        for index, par in self.owner.parameters.items():
            server.setpar(index, par.initialValue()) # info[0] = init value
            # fix if fixed.  Note: all parameters are free after server.reset().
            if par.fixed:
                server.fixpar(index)

        # all ready here
        server.calc()

        # get results
        self.rcalc = server.getR()
        self.Gcalc = server.getpdf_fit()

# 需要导入模块: from diffpy.pdffit2 import PdfFit [as 别名]
# 或者: from diffpy.pdffit2.PdfFit import setpar [as 别名]
class constrainExceptions(unittest.TestCase):

    def setUp(self):
        self.P = PdfFit()
        self.par = 1
        return

    def tearDown(self):
        self.P = None
        return

    def test_constraintError(self):
        """raise constraintError when constraint is bad"""
        self.P.read_struct(datafile("Ni.stru"))
        self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0)
        self.P.constrain('x(1)', '[email protected]')
        self.P.setpar(1, 0.01)
        self.assertRaises(pdffit2.constraintError, self.P.calc)
        self.assertRaises(pdffit2.constraintError, self.P.refine)
        return

    def test_unassignedError(self):
        """raise pdffit2.unassignedError when variable is undefined"""
        self.assertRaises(pdffit2.unassignedError, self.P.constrain, self.P.x(1),
                self.par)
        return

    def test_ValueError(self):
        """raise ValueError when a variable index does not exist"""
        self.P.read_struct(datafile("Ni.stru"))
        self.assertRaises(ValueError, self.P.constrain, self.P.x(6),
                self.par)
        return

    def test_constrainNonRefVar(self):
        "raise constraintError when attempting to constrain non-refinables"
        self.P.read_struct(datafile("Ni.stru"))
        self.P.read_data(datafile("Ni.dat"), 'X', 25.0, 0.0)
        self.assertRaises(pdffit2.constraintError,
                self.P.constrain, 'rcut', '@7')
        self.assertRaises(pdffit2.constraintError,
                self.P.constrain, 'rcut', 13)
        self.assertRaises(pdffit2.constraintError,
                self.P.constrain, 'stepcut', '@17')
        return

# 需要导入模块: from diffpy.pdffit2 import PdfFit [as 别名]
# 或者: from diffpy.pdffit2.PdfFit import setpar [as 别名]
class save_resExceptions(unittest.TestCase):

    def setUp(self):
        self.P = PdfFit()
        self.resfile = "temp.res"

    def tearDown(self):
        del self.P

    def test_IOError(self):
        """raise IOError when residual file cannot be saved"""
        self.P.read_struct(datafile("Ni.stru"))
        self.P.read_data(datafile("Ni.dat"), 'X', 30.0, 0.0)
        self.P.constrain(self.P.lat(1), 1)
        self.P.setpar(1, 3.0)
        self.P.pdfrange(1,2.0,10.0)
        self.P.refine_step()
        self.assertRaises(IOError, self.P.save_res,
                "nodir183160/"+self.resfile)

    def test_unassignedError(self):
        """raise pdffit2.unassignedError when structure is undefined"""
        self.assertRaises(pdffit2.unassignedError, self.P.save_res,
        self.resfile)

# 需要导入模块: from diffpy.pdffit2 import PdfFit [as 别名]
# 或者: from diffpy.pdffit2.PdfFit import setpar [as 别名]
class TestSphereEnvelope(unittest.TestCase):

    places = 6

    def setUp(self):
        self.P = PdfFit()
        return

    def tearDown(self):
        self.P = None
        return


    def test_calculation(self):
        """check calculation of sphere envelope factor
        """
        self.P.read_struct(datafile('Ni.stru'))
        self.P.alloc('X', 0.0, 0.05, 0.1, 10, 200)
        self.P.calc()
        d = 8.0
        r = numpy.array(self.P.getR())
        G0 = numpy.array(self.P.getpdf_fit())
        self.P.setvar('spdiameter', d)
        self.P.calc()
        G1 = numpy.array(self.P.getpdf_fit())
        dG = (G0*spherefactor(r, d) - G1)
        msd = numpy.dot(dG, dG)/len(r)
        self.assertAlmostEqual(0.0, numpy.sqrt(msd), self.places)
        return


    def test_refinement(self):
        """check refinement of sphere envelope factor
        """
        dcheck = 8.0
        dstart = 12.0
        self.P.read_struct(datafile('Ni.stru'))
        self.P.alloc('X', 0.0, 0.05, 0.1, 10, 200)
        self.P.setvar('spdiameter', dcheck)
        self.P.calc()
        r = numpy.array(self.P.getR())
        Gd8 = numpy.array(self.P.getpdf_fit())
        Gd8noise = Gd8
        Gd8noise[::2] += 0.01
        Gd8noise[1::2] -= 0.01
        self.P.reset()
        self.P.read_struct(datafile('Ni.stru'))
        self.P.read_data_lists('X', 0.0, 0.05, list(r), list(Gd8noise))
        self.P.constrain('spdiameter', '@8')
        self.P.setpar(8, dstart)
        self.P.refine()
        dfinal = self.P.getvar('spdiameter')
        self.assertAlmostEqual(dcheck, dfinal, 3)
        return


    def test_twophase_calculation(self):
        """check PDF calculation for 2 phases with different spdiameters
        """
        d1 = 6
        d2 = 9
        self.P.read_struct(datafile('Ni.stru'))
        self.P.alloc('X', 0.0, 0.05, 0.1, 10, 200)
        self.P.setvar('spdiameter', d1)
        self.P.calc()
        G1 = numpy.array(self.P.getpdf_fit())
        self.P.reset()
        self.P.read_struct(datafile('PbScW25TiO3.stru'))
        self.P.alloc('X', 0.0, 0.05, 0.1, 10, 200)
        self.P.setvar('spdiameter', d2)
        self.P.calc()
        G2 = numpy.array(self.P.getpdf_fit())
        self.P.reset()
        self.P.read_struct(datafile('Ni.stru'))
        self.P.read_struct(datafile('PbScW25TiO3.stru'))
        self.P.alloc('X', 0.0, 0.05, 0.1, 10, 200)
        self.P.setphase(1)
        self.P.setvar('spdiameter', d1)
        self.P.setphase(2)
        self.P.setvar('spdiameter', d2)
        self.P.calc()
        Gtot = numpy.array(self.P.getpdf_fit())
        dG = (G1 + G2 - Gtot)
        r = numpy.array(self.P.getR())
        msd = numpy.dot(dG, dG)/len(r)
        self.assertAlmostEqual(0.0, numpy.sqrt(msd), self.places)
        return


    def test_twophase_refinement(self):
        """check PDF refinement of 2 phases that have different spdiameter.
        """
        dcheck1 = 8.0
        dstart1 = 8.2
        dcheck2 = 6.0
        dstart2 = 5.5
        self.P.read_struct(datafile('Ni.stru'))
        self.P.alloc('X', 0.0, 0.05, 0.1, 10, 200)
        self.P.setvar('spdiameter', dcheck1)
        self.P.calc()
#.........这里部分代码省略.........

# 需要导入模块: from diffpy.pdffit2 import PdfFit [as 别名]
# 或者: from diffpy.pdffit2.PdfFit import setpar [as 别名]
qmax = 30.0  # Q-cutoff used in PDF calculation in 1/A
qdamp = 0.01 # instrument Q-resolution factor, responsible for PDF decay
pf.read_data('Ni-xray.gr', 'X', qmax, qdamp)

# Load nickel structure, must be in PDFFIT or DISCUS format
pf.read_struct('Ni.stru')

# Configure Refinement -------------------------------------------------------

# Refine lattice parameters a, b, c.
# Make them all equal to parameter @1.
pf.constrain(pf.lat(1), "@1")
pf.constrain(pf.lat(2), "@1")
pf.constrain(pf.lat(3), "@1")
# set initial value of parameter @1
pf.setpar(1, pf.lat(1))

# Refine phase scale factor.  Right side can have formulas.
pf.constrain('pscale', '@20 * 2')
pf.setpar(20, pf.getvar(pf.pscale) / 2.0)

# Refine PDF damping due to instrument Q-resolution.
# Left side can be also passed as a reference to PdfFit object
pf.constrain(pf.qdamp, '@21')
pf.setpar(21, 0.03)

# Refine sharpening factor for correlated motion of close atoms.
pf.constrain(pf.delta2, 22)
pf.setpar(22, 0.0003)

# Set all temperature factors isotropic and equal to @4