def parseLines(self, lines): """Parse list of lines in DISCUS format. Return PDFFitStructure instance or raise StructureFormatError. """ self.lines = lines ilines = self._linesIterator() self.stru = PDFFitStructure() record_parsers = { "cell": self._parse_cell, "format": self._parse_format, "generator": self._parse_not_implemented, "molecule": self._parse_not_implemented, "ncell": self._parse_ncell, "spcgr": self._parse_spcgr, "symmetry": self._parse_not_implemented, "title": self._parse_title, "shape": self._parse_shape, } try: # parse header for self.line in ilines: words = self.line.split() if not words or words[0][0] == '#': continue if words[0] == 'atoms': break rp = record_parsers.get(words[0], self._parse_unknown_record) rp(words) # check if cell has been defined if not self.cell_read: emsg = "%d: unit cell not defined" % self.nl raise StructureFormatError(emsg) # parse atoms for self.line in ilines: words = self.line.split() if not words or words[0][0] == '#': continue self._parse_atom(words) # self consistency check exp_natoms = reduce(lambda x, y: x * y, self.stru.pdffit['ncell']) # only check if ncell record exists if self.ncell_read and exp_natoms != len(self.stru): emsg = 'Expected %d atoms, read %d.' % \ (exp_natoms, len(self.stru)) raise StructureFormatError(emsg) # take care of superlattice if self.stru.pdffit['ncell'][:3] != [1, 1, 1]: latpars = list(self.stru.lattice.abcABG()) superlatpars = [ latpars[i] * self.stru.pdffit['ncell'][i] for i in range(3) ] + latpars[3:] superlattice = Lattice(*superlatpars) self.stru.placeInLattice(superlattice) self.stru.pdffit['ncell'] = [1, 1, 1, exp_natoms] except (ValueError, IndexError): exc_type, exc_value, exc_traceback = sys.exc_info() emsg = "%d: file is not in DISCUS format" % self.nl raise StructureFormatError, emsg, exc_traceback return self.stru
def __init__(self, name, *args, **kwargs): """Initialize PDFStructure. name -- name of this PDFStructure. args, kwargs -- optional arguments passed to parent Structure class """ PDFComponent.__init__(self, name) PDFFitStructure.__init__(self, *args, **kwargs) return
def toLines(self, stru): """Convert Structure stru to a list of lines in PDFfit format. Return list of strings. """ # build the stru_pdffit dictionary initialized from the defaults # in PDFFitStructure stru_pdffit = PDFFitStructure().pdffit if stru.pdffit: stru_pdffit.update(stru.pdffit) lines = [] # default values of standard deviations d_sigxyz = numpy.zeros(3, dtype=float) d_sigo = 0.0 d_sigU = numpy.zeros((3,3), dtype=float) # here we can start l = "title " + stru.title lines.append( l.strip() ) lines.append( "format pdffit" ) lines.append( "scale %9.6f" % stru_pdffit["scale"] ) lines.append( "sharp %9.6f, %9.6f, %9.6f, %9.6f" % ( stru_pdffit["delta2"], stru_pdffit["delta1"], stru_pdffit["sratio"], stru_pdffit["rcut"]) ) lines.append( "spcgr " + stru_pdffit["spcgr"] ) if stru_pdffit.get('spdiameter', 0.0) > 0.0: line = 'shape sphere, %g' % stru_pdffit['spdiameter'] lines.append(line) if stru_pdffit.get('stepcut', 0.0) > 0.0: line = 'shape stepcut, %g' % stru_pdffit['stepcut'] lines.append(line) lat = stru.lattice lines.append( "cell %9.6f, %9.6f, %9.6f, %9.6f, %9.6f, %9.6f" % ( lat.a, lat.b, lat.c, lat.alpha, lat.beta, lat.gamma) ) lines.append( "dcell %9.6f, %9.6f, %9.6f, %9.6f, %9.6f, %9.6f" % tuple(stru_pdffit["dcell"]) ) lines.append( "ncell %9i, %9i, %9i, %9i" % (1, 1, 1, len(stru)) ) lines.append( "atoms" ) for a in stru: ad = a.__dict__ lines.append( "%-4s %17.8f %17.8f %17.8f %12.4f" % ( a.element.upper(), a.xyz[0], a.xyz[1], a.xyz[2], a.occupancy) ) sigmas = numpy.concatenate( ( ad.get("sigxyz", d_sigxyz), [ad.get("sigo", d_sigo)] ) ) lines.append( " %18.8f %17.8f %17.8f %12.4f" % tuple(sigmas) ) sigU = ad.get("sigU", d_sigU) Uii = ( a.U[0][0], a.U[1][1], a.U[2][2] ) Uij = ( a.U[0][1], a.U[0][2], a.U[1][2] ) sigUii = ( sigU[0][0], sigU[1][1], sigU[2][2] ) sigUij = ( sigU[0][1], sigU[0][2], sigU[1][2] ) lines.append( " %18.8f %17.8f %17.8f" % Uii ) lines.append( " %18.8f %17.8f %17.8f" % sigUii ) lines.append( " %18.8f %17.8f %17.8f" % Uij ) lines.append( " %18.8f %17.8f %17.8f" % sigUij ) return lines
def get_structure(self, ip): """get_structure(ip) --> Get a copy of specified phase data. ip -- index of existing PdfFit phase starting from 1 Return Structure object from diffpy.Structure. Raise pdffit2.unassignedError if phase ip is undefined. """ from diffpy.Structure import PDFFitStructure s = self.save_struct_string(ip) stru = PDFFitStructure() stru.readStr(s, 'pdffit') return stru
def toLines(self, stru): """Convert Structure stru to a list of lines in DISCUS format. Return list of strings. """ self.stru = stru # if necessary, convert self.stru to PDFFitStructure if not isinstance(stru, PDFFitStructure): self.stru = PDFFitStructure(stru) # build the stru_pdffit dictionary initialized from the defaults # in PDFFitStructure stru_pdffit = PDFFitStructure().pdffit if stru.pdffit: stru_pdffit.update(stru.pdffit) # here we can start self.lines = lines = [] lines.append( "title " + self.stru.title.strip() ) lines.append( "spcgr " + stru_pdffit["spcgr"] ) if stru_pdffit.get('spdiameter', 0.0) > 0.0: line = 'shape sphere, %g' % stru_pdffit['spdiameter'] lines.append(line) if stru_pdffit.get('stepcut', 0.0) > 0.0: line = 'shape stepcut, %g' % stru_pdffit['stepcut'] lines.append(line) lines.append( "cell %9.6f, %9.6f, %9.6f, %9.6f, %9.6f, %9.6f" % self.stru.lattice.abcABG() ) lines.append( "ncell %9i, %9i, %9i, %9i" % (1, 1, 1, len(self.stru)) ) lines.append( "atoms" ) for a in self.stru: lines.append( "%-4s %17.8f %17.8f %17.8f %12.4f" % ( a.element.upper(), a.xyz[0], a.xyz[1], a.xyz[2], a.Bisoequiv)) return lines
def testGenerator(self): qmax = 27.0 gen = self.gen gen.setScatteringType('N') self.assertEqual('N', gen.getScatteringType()) gen.setQmax(qmax) self.assertAlmostEqual(qmax, gen.getQmax()) from diffpy.Structure import PDFFitStructure stru = PDFFitStructure() ciffile = datafile("ni.cif") stru.read(ciffile) for i in range(4): stru[i].Bisoequiv = 1 gen.setStructure(stru) calc = gen._calc # Test parameters for par in gen.iterPars(recurse=False): pname = par.name defval = calc._getDoubleAttr(pname) self.assertEquals(defval, par.getValue()) # Test setting values par.setValue(1.0) self.assertEquals(1.0, par.getValue()) par.setValue(defval) self.assertEquals(defval, par.getValue()) r = numpy.arange(0, 10, 0.1) y = gen(r) # Now create a reference PDF. Since the calculator is testing its # output, we just have to make sure we can calculate from the # PDFGenerator interface. from diffpy.srreal.pdfcalculator import PDFCalculator calc = PDFCalculator() calc.rstep = r[1] - r[0] calc.rmin = r[0] calc.rmax = r[-1] + 0.5 * calc.rstep calc.qmax = qmax calc.setScatteringFactorTableByType('N') calc.eval(stru) yref = calc.pdf diff = y - yref res = numpy.dot(diff, diff) self.assertAlmostEquals(0, res) return
def testGenerator(self): qmax = 27.0 gen = PDFGenerator() gen.setScatteringType('N') self.assertEqual('N', gen.getScatteringType()) gen.setQmax(qmax) self.assertAlmostEqual(qmax, gen.getQmax()) from diffpy.Structure import PDFFitStructure stru = PDFFitStructure() ciffile = datafile("ni.cif") stru.read(ciffile) for i in range(4): stru[i].Bisoequiv = 1 gen.setStructure(stru) calc = gen._calc # Test parameters for par in gen.iterPars(recurse = False): pname = par.name defval = calc._getDoubleAttr(pname) self.assertEquals(defval, par.getValue()) # Test setting values par.setValue(1.0) self.assertEquals(1.0, par.getValue()) par.setValue(defval) self.assertEquals(defval, par.getValue()) r = numpy.arange(0, 10, 0.1) y = gen(r) # Now create a reference PDF. Since the calculator is testing its # output, we just have to make sure we can calculate from the # PDFGenerator interface. from diffpy.srreal.pdfcalculator import PDFCalculator calc = PDFCalculator() calc.rstep = r[1] - r[0] calc.rmin = r[0] calc.rmax = r[-1] + 0.5 * calc.rstep calc.qmax = qmax calc.setScatteringFactorTableByType('N') calc.eval(stru) yref = calc.pdf diff = y - yref res = numpy.dot(diff, diff) self.assertAlmostEquals(0, res) return
def parseLines(self, lines): """Parse list of lines in DISCUS format. Return PDFFitStructure instance or raise StructureFormatError. """ self.lines = lines ilines = self._linesIterator() self.stru = PDFFitStructure() record_parsers = { "cell": self._parse_cell, "format": self._parse_format, "generator": self._parse_not_implemented, "molecule": self._parse_not_implemented, "ncell": self._parse_ncell, "spcgr": self._parse_spcgr, "symmetry": self._parse_not_implemented, "title": self._parse_title, "shape": self._parse_shape, } try: # parse header for self.line in ilines: words = self.line.split() if not words or words[0][0] == "#": continue if words[0] == "atoms": break rp = record_parsers.get(words[0], self._parse_unknown_record) rp(words) # check if cell has been defined if not self.cell_read: emsg = "%d: unit cell not defined" % self.nl raise StructureFormatError(emsg) # parse atoms for self.line in ilines: words = self.line.replace(",", " ").split() if not words or words[0][0] == "#": continue self._parse_atom(words) # self consistency check exp_natoms = reduce(lambda x, y: x * y, self.stru.pdffit["ncell"]) # only check if ncell record exists if self.ncell_read and exp_natoms != len(self.stru): emsg = "Expected %d atoms, read %d." % (exp_natoms, len(self.stru)) raise StructureFormatError(emsg) # take care of superlattice if self.stru.pdffit["ncell"][:3] != [1, 1, 1]: latpars = list(self.stru.lattice.abcABG()) superlatpars = [latpars[i] * self.stru.pdffit["ncell"][i] for i in range(3)] + latpars[3:] superlattice = Lattice(*superlatpars) self.stru.placeInLattice(superlattice) self.stru.pdffit["ncell"] = [1, 1, 1, exp_natoms] except (ValueError, IndexError): exc_type, exc_value, exc_traceback = sys.exc_info() emsg = "%d: file is not in DISCUS format" % self.nl raise StructureFormatError, emsg, exc_traceback return self.stru
def copy(self, other=None): """copy self to other. if other is None, create an instance other -- ref to other object returns reference to copied object """ if other is None: other = PDFStructure(self.name) for a in PDFFitStructure().__dict__: setattr(other, a, copy.deepcopy(getattr(self, a))) other[:] = copy.deepcopy(self[:]) return other
def toLines(self, stru): """Convert Structure stru to a list of lines in PDFfit format. Return list of strings. """ # build the stru_pdffit dictionary initialized from the defaults # in PDFFitStructure stru_pdffit = PDFFitStructure().pdffit if stru.pdffit: stru_pdffit.update(stru.pdffit) lines = [] # default values of standard deviations d_sigxyz = numpy.zeros(3, dtype=float) d_sigo = 0.0 d_sigU = numpy.zeros((3, 3), dtype=float) # here we can start l = "title " + stru.title lines.append(l.strip()) lines.append("format pdffit") lines.append("scale %9.6f" % stru_pdffit["scale"]) lines.append("sharp %9.6f, %9.6f, %9.6f, %9.6f" % (stru_pdffit["delta2"], stru_pdffit["delta1"], stru_pdffit["sratio"], stru_pdffit["rcut"])) lines.append("spcgr " + stru_pdffit["spcgr"]) if stru_pdffit.get('spdiameter', 0.0) > 0.0: line = 'shape sphere, %g' % stru_pdffit['spdiameter'] lines.append(line) if stru_pdffit.get('stepcut', 0.0) > 0.0: line = 'shape stepcut, %g' % stru_pdffit['stepcut'] lines.append(line) lat = stru.lattice lines.append("cell %9.6f, %9.6f, %9.6f, %9.6f, %9.6f, %9.6f" % (lat.a, lat.b, lat.c, lat.alpha, lat.beta, lat.gamma)) lines.append("dcell %9.6f, %9.6f, %9.6f, %9.6f, %9.6f, %9.6f" % tuple(stru_pdffit["dcell"])) lines.append("ncell %9i, %9i, %9i, %9i" % (1, 1, 1, len(stru))) lines.append("atoms") for a in stru: ad = a.__dict__ lines.append( "%-4s %17.8f %17.8f %17.8f %12.4f" % (a.element.upper(), a.xyz[0], a.xyz[1], a.xyz[2], a.occupancy)) sigmas = numpy.concatenate( (ad.get("sigxyz", d_sigxyz), [ad.get("sigo", d_sigo)])) lines.append(" %18.8f %17.8f %17.8f %12.4f" % tuple(sigmas)) sigU = ad.get("sigU", d_sigU) Uii = (a.U[0][0], a.U[1][1], a.U[2][2]) Uij = (a.U[0][1], a.U[0][2], a.U[1][2]) sigUii = (sigU[0][0], sigU[1][1], sigU[2][2]) sigUij = (sigU[0][1], sigU[0][2], sigU[1][2]) lines.append(" %18.8f %17.8f %17.8f" % Uii) lines.append(" %18.8f %17.8f %17.8f" % sigUii) lines.append(" %18.8f %17.8f %17.8f" % Uij) lines.append(" %18.8f %17.8f %17.8f" % sigUij) return lines
def read(self, filename, format='auto'): """Load structure from a file, raise ControlFileError for invalid or unknown structure format. filename -- file to be loaded format -- structure format such as 'pdffit', 'pdb', 'xyz'. When 'auto' all available formats are tried in a row. Return instance of StructureParser used to load the data. See Structure.read() for more info. """ from diffpy.Structure import StructureFormatError try: p = PDFFitStructure.read(self, filename, format) except StructureFormatError, err: import os.path emsg = "Unable to read file '%s'\n%s." % ( os.path.basename(filename), err) raise ControlFileError(emsg)
def parseLines(self, lines): """Parse list of lines in PDFfit format. Return Structure object or raise StructureFormatError. """ p_nl = 0 rlist = [] try: self.stru = PDFFitStructure() stru = self.stru cell_line_read = False stop = len(lines) while stop > 0 and lines[stop - 1].strip() == "": stop -= 1 ilines = iter(lines[:stop]) # read header of PDFFit file for l in ilines: p_nl += 1 words = l.split() if len(words) == 0 or words[0][0] == '#': continue elif words[0] == 'title': stru.title = l.lstrip()[5:].strip() elif words[0] == 'scale': stru.pdffit['scale'] = float(words[1]) elif words[0] == 'sharp': l1 = l.replace(',', ' ') sharp_pars = [float(w) for w in l1.split()[1:]] if len(sharp_pars) < 4: stru.pdffit['delta2'] = sharp_pars[0] stru.pdffit['sratio'] = sharp_pars[1] stru.pdffit['rcut'] = sharp_pars[2] else: stru.pdffit['delta2'] = sharp_pars[0] stru.pdffit['delta1'] = sharp_pars[1] stru.pdffit['sratio'] = sharp_pars[2] stru.pdffit['rcut'] = sharp_pars[3] elif words[0] == 'spcgr': key = 'spcgr' start = l.find(key) + len(key) value = l[start:].strip() stru.pdffit['spcgr'] = value elif words[0] == 'shape': self._parse_shape(l) elif words[0] == 'cell': cell_line_read = True l1 = l.replace(',', ' ') latpars = [float(w) for w in l1.split()[1:7]] stru.lattice = Lattice(*latpars) elif words[0] == 'dcell': l1 = l.replace(',', ' ') stru.pdffit['dcell'] = [float(w) for w in l1.split()[1:7]] elif words[0] == 'ncell': l1 = l.replace(',', ' ') stru.pdffit['ncell'] = [int(w) for w in l1.split()[1:5]] elif words[0] == 'format': if words[1] != 'pdffit': emsg = "%d: file is not in PDFfit format" % p_nl raise StructureFormatError(emsg) elif words[0] == 'atoms' and cell_line_read: break else: self.ignored_lines.append(l) # Header reading finished, check if required lines were present. if not cell_line_read: emsg = "%d: file is not in PDFfit format" % p_nl raise StructureFormatError(emsg) # Load data from atom entries. p_natoms = reduce(lambda x, y: x * y, stru.pdffit['ncell']) # we are now inside data block for l in ilines: p_nl += 1 wl1 = l.split() element = wl1[0][0].upper() + wl1[0][1:].lower() xyz = [float(w) for w in wl1[1:4]] occ = float(wl1[4]) stru.addNewAtom(element, xyz=xyz, occupancy=occ) a = stru.getLastAtom() p_nl += 1 wl2 = ilines.next().split() a.sigxyz = [float(w) for w in wl2[0:3]] a.sigo = float(wl2[3]) p_nl += 1 wl3 = ilines.next().split() p_nl += 1 wl4 = ilines.next().split() p_nl += 1 wl5 = ilines.next().split() p_nl += 1 wl6 = ilines.next().split() a.sigU = numpy.zeros((3, 3), dtype=float) a.U11 = float(wl3[0]) a.U22 = float(wl3[1]) a.U33 = float(wl3[2]) a.sigU[0, 0] = float(wl4[0]) a.sigU[1, 1] = float(wl4[1]) a.sigU[2, 2] = float(wl4[2]) a.U12 = float(wl5[0]) a.U13 = float(wl5[1]) a.U23 = float(wl5[2]) a.sigU[0, 1] = a.sigU[1, 0] = float(wl6[0]) a.sigU[0, 2] = a.sigU[2, 0] = float(wl6[1]) a.sigU[1, 2] = a.sigU[2, 1] = float(wl6[2]) if len(stru) != p_natoms: emsg = "expected %d atoms, read %d" % (p_natoms, len(stru)) raise StructureFormatError(emsg) if stru.pdffit['ncell'][:3] != [1, 1, 1]: superlatpars = [ latpars[i] * stru.pdffit['ncell'][i] for i in range(3) ] + latpars[3:] superlattice = Lattice(*superlatpars) stru.placeInLattice(superlattice) stru.pdffit['ncell'] = [1, 1, 1, p_natoms] except (ValueError, IndexError): emsg = "%d: file is not in PDFfit format" % p_nl exc_type, exc_value, exc_traceback = sys.exc_info() raise StructureFormatError, emsg, exc_traceback return stru
class P_discus(StructureParser): """Parser for DISCUS structure format. The parser chokes on molecule and generator records. """ def __init__(self): StructureParser.__init__(self) self.format = "discus" # helper variables self.nl = None self.lines = None self.line = None self.stru = None self.ignored_lines = [] self.cell_read = False self.ncell_read = False return def parseLines(self, lines): """Parse list of lines in DISCUS format. Return PDFFitStructure instance or raise StructureFormatError. """ self.lines = lines ilines = self._linesIterator() self.stru = PDFFitStructure() record_parsers = { "cell" : self._parse_cell, "format" : self._parse_format, "generator" : self._parse_not_implemented, "molecule" : self._parse_not_implemented, "ncell" : self._parse_ncell, "spcgr" : self._parse_spcgr, "symmetry" : self._parse_not_implemented, "title" : self._parse_title, "shape" : self._parse_shape, } try: # parse header for self.line in ilines: words = self.line.split() if not words or words[0][0] == '#': continue if words[0] == 'atoms': break rp = record_parsers.get(words[0], self._parse_unknown_record) rp(words) # check if cell has been defined if not self.cell_read: emsg = "%d: unit cell not defined" % self.nl raise StructureFormatError(emsg) # parse atoms for self.line in ilines: words = self.line.replace(',', ' ').split() if not words or words[0][0] == '#': continue self._parse_atom(words) # self consistency check exp_natoms = reduce(lambda x,y : x*y, self.stru.pdffit['ncell']) # only check if ncell record exists if self.ncell_read and exp_natoms != len(self.stru): emsg = 'Expected %d atoms, read %d.' % \ (exp_natoms, len(self.stru)) raise StructureFormatError(emsg) # take care of superlattice if self.stru.pdffit['ncell'][:3] != [1,1,1]: latpars = list(self.stru.lattice.abcABG()) superlatpars = [ latpars[i]*self.stru.pdffit['ncell'][i] for i in range(3) ] + latpars[3:] superlattice = Lattice(*superlatpars) self.stru.placeInLattice(superlattice) self.stru.pdffit['ncell'] = [1, 1, 1, exp_natoms] except (ValueError, IndexError): exc_type, exc_value, exc_traceback = sys.exc_info() emsg = "%d: file is not in DISCUS format" % self.nl raise StructureFormatError, emsg, exc_traceback return self.stru # End of parseLines def toLines(self, stru): """Convert Structure stru to a list of lines in DISCUS format. Return list of strings. """ self.stru = stru # if necessary, convert self.stru to PDFFitStructure if not isinstance(stru, PDFFitStructure): self.stru = PDFFitStructure(stru) # build the stru_pdffit dictionary initialized from the defaults # in PDFFitStructure stru_pdffit = PDFFitStructure().pdffit if stru.pdffit: stru_pdffit.update(stru.pdffit) # here we can start self.lines = lines = [] lines.append( "title " + self.stru.title.strip() ) lines.append( "spcgr " + stru_pdffit["spcgr"] ) if stru_pdffit.get('spdiameter', 0.0) > 0.0: line = 'shape sphere, %g' % stru_pdffit['spdiameter'] lines.append(line) if stru_pdffit.get('stepcut', 0.0) > 0.0: line = 'shape stepcut, %g' % stru_pdffit['stepcut'] lines.append(line) lines.append( "cell %9.6f, %9.6f, %9.6f, %9.6f, %9.6f, %9.6f" % self.stru.lattice.abcABG() ) lines.append( "ncell %9i, %9i, %9i, %9i" % (1, 1, 1, len(self.stru)) ) lines.append( "atoms" ) for a in self.stru: lines.append( "%-4s %17.8f %17.8f %17.8f %12.4f" % ( a.element.upper(), a.xyz[0], a.xyz[1], a.xyz[2], a.Bisoequiv)) return lines # End of toLines def _linesIterator(self): """Iterator over self.lines, which increments self.nl """ # ignore trailing empty lines stop = len(self.lines) while stop > 0 and self.lines[stop-1].strip() == "": stop -= 1 self.nl = 0 # read header of PDFFit file for self.line in self.lines[:stop]: self.nl += 1 yield self.line # end of _linesIterator def _parse_cell(self, words): """Process the cell record from DISCUS structure file. """ # split again on spaces or commas words = self.line.replace(',', ' ').split() latpars = [ float(w) for w in words[1:7] ] try: self.stru.lattice.setLatPar(*latpars) except ZeroDivisionError: emsg = "%d: Invalid lattice parameters - zero cell volume" % \ self.nl raise StructureFormatError(emsg) self.cell_read = True return def _parse_format(self, words): """Process the format record from DISCUS structure file. """ if words[1] == 'pdffit': emsg = "%d: file is not in DISCUS format" % self.nl raise StructureFormatError(emsg) return def _parse_ncell(self, words): """Process the ncell record from DISCUS structure file. """ # split again on spaces or commas words = self.line.replace(',', ' ').split() self.stru.pdffit['ncell'] = [ int(w) for w in words[1:5] ] self.ncell_read = True return def _parse_spcgr(self, words): """Process the spcgr record from DISCUS structure file. """ self.stru.pdffit['spcgr'] = ''.join(words[1:]) return def _parse_title(self, words): """Process the title record from DISCUS structure file. """ self.stru.title = self.line.lstrip()[5:].strip() return def _parse_shape(self, words): """Process the shape record from DISCUS structure file. """ # strip away any commas linefixed = " ".join(words).replace(',', ' ') wordsfixed = linefixed.split() shapetype = wordsfixed[1] if shapetype == 'sphere': self.stru.pdffit['spdiameter'] = float(words[2]) elif shapetype == 'stepcut': self.stru.pdffit['stepcut'] = float(words[2]) else: emsg = 'Invalid type of particle shape correction %r' % shapetype raise StructureFormatError, emsg return def _parse_atom(self, words): """Process atom records in DISCUS structure file. """ element = words[0][0:1].upper() + words[0][1:].lower() xyz = [float(w) for w in words[1:4]] Biso = float(words[4]) self.stru.addNewAtom(element, xyz) a = self.stru.getLastAtom() a.Bisoequiv = Biso return def _parse_unknown_record(self, words): """Process unknown record in DISCUS structure file. Silently ignores the line and adds it to self.ignored_lines Raises StructureFormatError. """ self.ignored_lines.append(self.line) return def _parse_not_implemented(self, words): """Process the unimplemented records from DISCUS structure file. Raises NotImplementedError. """ emsg = "%d: reading of DISCUS record %r is not implemented." % \ (self.nl, words[0]) raise NotImplementedError(emsg)