Changeset 3011

Timestamp:

Aug 16, 2017 4:16:55 PM (4 years ago)

Author:

odonnell

Message:

CIF export. changelist:

• Start using argparse module in GSASIIscriptable.py
• G2Phase now has export_CIF method
• GSASIIscriptable export method now works
• refactoring of exports/G2export_CIF.py to reduce code duplication

Location:

trunk

Files:

• GSASIIscriptable.py (modified) (9 diffs)
• exports/G2export_CIF.py (modified) (114 diffs)
• exports/__init__.py (added)

trunk/GSASIIscriptable.py

@@ -33 +33 @@
 from __future__ import division, print_function # needed?
 import os.path as ospath
+import datetime as dt
 import sys
 import cPickle
@@ -377 +378 @@
     generalData['Mass'] = G2mth.getMass(generalData)
 
+
+############################################
+############ CIF export helpers ############
+############################################
+## These functions are translated from
+## exports/G2export_CIF.py
+## They are used in G2Phase.export_CIF
+
+
+
 def make_empty_project(author=None, filename=None):
     """Creates an dictionary in the style of GSASIIscriptable, for an empty
@@ -1485 +1496 @@
         return G2obj.PhaseRanIdLookup[self.ranId]
 
-    def cell_dict(self):
+    def get_cell(self):
         """Returns a dictionary of the cell parameters, with keys:
-            'a', 'b', 'c', 'alpha', 'beta', 'gamma', 'vol'
+            'length_a', 'length_b', 'length_c', 'angle_alpha', 'angle_beta', 'angle_gamma', 'volume'
 
         :returns: a dict"""
         cell = self['General']['Cell']
-        return {'a': cell[1], 'b': cell[2], 'c': cell[3],
-                'alpha': cell[4], 'beta': cell[5], 'gamma': cell[6],
-                'vol': cell[7]}
+        return {'length_a': cell[1], 'length_b': cell[2], 'length_c': cell[3],
+                'angle_alpha': cell[4], 'angle_beta': cell[5], 'angle_gamma': cell[6],
+                'volume': cell[7]}
+
+    def export_CIF(self, outputname, quickmode=True):
+        """Write this phase to a .cif file named outputname
+
+        :param str outputname: The name of the .cif file to write to
+        :param bool quickmode: Currently ignored. Carryover from exports.G2export_CIF"""
+        # This code is all taken from exports/G2export_CIF.py
+        # Functions copied have the same names
+        import GSASIImath as G2mth
+        import GSASIImapvars as G2mv
+        from exports import G2export_CIF as cif
+
+        CIFdate = dt.datetime.strftime(dt.datetime.now(),"%Y-%m-%dT%H:%M")
+        CIFname = os.path.splitext(self.proj.filename)[0]
+        CIFname = os.path.split(CIFname)[1]
+        CIFname = ''.join([c if ord(c) < 128 else ''
+                           for c in CIFname.replace(' ', '_')])
+        try:
+            author = self.proj['Controls'].get('Author','').strip()
+        except KeyError:
+            pass
+        oneblock = True
+
+        covDict = self.proj['Covariance']
+        parmDict = dict(zip(covDict.get('varyList',[]),
+                            covDict.get('variables',[])))
+        sigDict = dict(zip(covDict.get('varyList',[]),
+                           covDict.get('sig',[])))
+
+        if covDict.get('covMatrix') is not None:
+            sigDict.update(G2mv.ComputeDepESD(covDict['covMatrix'],
+                                              covDict['varyList'],
+                                              parmDict))
+
+        with open(outputname, 'w') as fp:
+            fp.write(' \n' + 70*'#' + '\n')
+            cif.WriteCIFitem(fp, 'data_' + CIFname)
+            # from exports.G2export_CIF.WritePhaseInfo
+            cif.WriteCIFitem(fp, '\n# phase info for '+str(self.name) + ' follows')
+            cif.WriteCIFitem(fp, '_pd_phase_name', self.name)
+            # TODO get esds
+            cellDict = self.get_cell()
+            defsigL = 3*[-0.00001] + 3*[-0.001] + [-0.01] # significance to use when no sigma
+            names = ['length_a','length_b','length_c',
+                     'angle_alpha','angle_beta ','angle_gamma',
+                     'volume']
+            for key, val in cellDict.items():
+                cif.WriteCIFitem(fp, '_cell_' + key, G2mth.ValEsd(val))
+
+            cif.WriteCIFitem(fp, '_symmetry_cell_setting',
+                         self['General']['SGData']['SGSys'])
+
+            spacegroup = self['General']['SGData']['SpGrp'].strip()
+            # regularize capitalization and remove trailing H/R
+            spacegroup = spacegroup[0].upper() + spacegroup[1:].lower().rstrip('rh ')
+            cif.WriteCIFitem(fp, '_symmetry_space_group_name_H-M', spacegroup)
+
+            # generate symmetry operations including centering and center of symmetry
+            SymOpList, offsetList, symOpList, G2oprList, G2opcodes = G2spc.AllOps(
+                self['General']['SGData'])
+            cif.WriteCIFitem(fp, 'loop_\n    _space_group_symop_id\n    _space_group_symop_operation_xyz')
+            for i, op in enumerate(SymOpList,start=1):
+                cif.WriteCIFitem(fp, '   {:3d}  {:}'.format(i,op.lower()))
+
+            # TODO skipped histograms, exports/G2export_CIF.py:880
+
+            # report atom params
+            if self['General']['Type'] in ['nuclear','macromolecular']:        #this needs macromolecular variant, etc!
+                cif.WriteAtomsNuclear(fp, self.data, self.name, parmDict, sigDict, [])
+                # self._WriteAtomsNuclear(fp, parmDict, sigDict)
+            else:
+                raise Exception,"no export for "+str(self['General']['Type'])+" coordinates implemented"
+            # report cell contents
+            cif.WriteComposition(fp, self.data, self.name, parmDict)
+            if not quickmode and self['General']['Type'] == 'nuclear':      # report distances and angles
+                # WriteDistances(fp,self.name,SymOpList,offsetList,symOpList,G2oprList)
+                raise NotImplementedError("only quickmode currently supported")
+            if 'Map' in self['General'] and 'minmax' in self['General']['Map']:
+                cif.WriteCIFitem(fp,'\n# Difference density results')
+                MinMax = self['General']['Map']['minmax']
+                cif.WriteCIFitem(fp,'_refine_diff_density_max',G2mth.ValEsd(MinMax[0],-0.009))
+                cif.WriteCIFitem(fp,'_refine_diff_density_min',G2mth.ValEsd(MinMax[1],-0.009))
+
 
     def set_refinements(self, refs):
@@ -1682 +1776 @@
 
 
+# TODO SUBPARSERS
+
 def create(*args):
     """The create subcommand.
 
     Should be passed all the command-line arguments after `create`"""
-    proj = G2Project(filename=args[0])
+    import argparse
+    parser = argparse.ArgumentParser(prog=' '.join([sys.argv[0], sys.argv[1]]))
+    parser.add_argument('filename',
+                        help='the project file to create. should end in .gpx')
+    parser.add_argument('-g', '--histograms', nargs='+',
+                        help='list of histograms to add')
+    parser.add_argument('-p', '--phases', nargs='+',
+                        help='list of phases to add')
+    results = parser.parse_args(args)
+
+    proj = G2Project(filename=filename)
 
     isPhase = False
@@ -1724 +1830 @@
 def dump(*args):
     """The dump subcommand"""
-    raw = True
-    histograms = False
-    phases = False
-    filenames = []
-    for arg in args:
-        if arg in ['-h', '--histograms']:
-            histograms = True
-            raw = False
-        elif arg in ['-p', '--phases']:
-            phases = True
-            raw = False
-        elif arg in ['-r', '--raw']:
-            raw = True
-        else:
-            filenames.append(arg)
-    if raw:
+    import argparse
+    parser = argparse.ArgumentParser(prog=' '.join([sys.argv[0], sys.argv[1]]))
+    parser.add_argument('-g', '--histograms', action='store_true',
+                        help='list histograms in files, overrides --raw')
+    parser.add_argument('-p', '--phases', action='store_true',
+                        help='list phases in files, overrides --raw')
+    parser.add_argument('-r', '--raw', action='store_true',
+                        help='dump raw file contents')
+    parser.add_argument('files', nargs='*')
+    results = parser.parse_args(args)
+
+    if not results.histograms and not results.phases:
+        results.raw = True
+    if results.raw:
         import IPython.lib.pretty as pretty
-    for fname in filenames:
-        if raw:
+
+    for fname in results.files:
+        if results.raw:
             proj, nameList = LoadDictFromProjFile(fname)
             print("file:", fname)
@@ -1751 +1856 @@
         else:
             proj = G2Project(fname)
-            if histograms:
+            if results.histograms:
                 hists = proj.histograms()
                 for h in hists:
                     print(fname, "hist", h.id, h.name)
-            if phases:
+            if results.phases:
                 phase_list = proj.phases()
                 for p in phase_list:
@@ -1776 +1881 @@
     """The refine subcommand"""
     proj = G2Project(args[0])
-    proj.refine()
+    if len(args) == 1:
+        proj.refine()
+    elif len(args) == 2:
+        import json
+        with open(args[1]) as refs:
+            refs = json.load(refs)
+        proj.do_refinements(refs['refinements'])
+    else:
+        print("Refine not sure what to do with args:", args)
 
 
@@ -1787 +1900 @@
     """The export subcommand"""
     # Export CIF or Structure or ...
-    raise NotImplementedError("export is not yet implemented")
+    gpxfile, phase, exportfile = args
+    proj = G2Project(gpxfile)
+    phase = proj.phase(phase)
+    phase.export_CIF(exportfile)
 
 
@@ -1799 +1915 @@
 
 def main():
-    '''TODO: the command-line options need some thought
+    '''The command line interface for GSASIIscriptable.
+
+    Executes one of the following subcommands:
+
+        * :func:`create`
+        * :func:`dump`
+        * :func:`refine`
+        * :func:`seqrefine`
+        * :func:`export`
+        * :func:`browse`
+
+    .. seealso::
+        :func:`create`
+        :func:`dump`
+        :func:`refine`
+        :func:`seqrefine`
+        :func:`export`
+        :func:`browse`
     '''
-    argv = sys.argv
-    if len(argv) > 1 and argv[1] in subcommands:
-        subcommands[argv[1]](*argv[2:])
-    elif len(argv) == 1 or argv[1] in ('help', '--help', '-h'):
-        # TODO print usage
-        subcommand_names = ' | '.join(sorted(subcommands.keys()))
-        print("USAGE: {} [ {} ] ...".format(argv[0], subcommand_names))
-    else:
-        print("Unknown subcommand: {}".format(argv[1]))
-        print("Available subcommands:")
-        for name in sorted(subcommands.keys()):
-            print("\t{}".format(name))
-        sys.exit(-1)
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('subcommand', choices=sorted(subcommands.keys()),
+                        help='The subcommand to be executed')
+
+    result = parser.parse_args(sys.argv[1:2])
+    sub = result.subcommand
+    subcommands[sub](*sys.argv[2:])
+
+    # argv = sys.argv
+    # if len(argv) > 1 and argv[1] in subcommands:
+    #     subcommands[argv[1]](*argv[2:])
+    # elif len(argv) == 1 or argv[1] in ('help', '--help', '-h'):
+    #     # TODO print usage
+    #     subcommand_names = ' | '.join(sorted(subcommands.keys()))
+    #     print("USAGE: {} [ {} ] ...".format(argv[0], subcommand_names))
+    # else:
+    #     print("Unknown subcommand: {}".format(argv[1]))
+    #     print("Available subcommands:")
+    #     for name in sorted(subcommands.keys()):
+    #         print("\t{}".format(name))
+    #     sys.exit(-1)
+    # sys.exit(0)
+
     # arg = sys.argv
     # print(arg)

trunk/exports/G2export_CIF.py

@@ -15 +15 @@
 entire project in a complete CIF intended for submission as a
 publication. In addition, there are three subclasses of :class:`ExportCIF`:
-:class:`ExportProjectCIF`, 
+:class:`ExportProjectCIF`,
 :class:`ExportPhaseCIF` and :class:`ExportDataCIF` where extra parameters
 for the _Exporter() determine if a project, single phase or data set are written.
@@ -43 +43 @@
 CIFdic = None
 
+# Refactored over here to allow access by GSASIIscriptable.py
+def WriteCIFitem(fp, name, value=''):
+    '''Helper function for writing CIF output. Translated from exports/G2export_CIF.py'''
+    # Ignore unicode issues
+    if value:
+        if "\n" in value or len(value)> 70:
+            if name.strip():
+                fp.write(name+'\n')
+            fp.write('; '+value+'\n')
+            fp.write('; '+'\n')
+        elif " " in value:
+            if len(name)+len(value) > 65:
+                fp.write(name + '\n   ' + '"' + str(value) + '"'+'\n')
+            else:
+                fp.write(name + '  ' + '"' + str(value) + '"'+'\n')
+        else:
+            if len(name)+len(value) > 65:
+                fp.write(name+'\n   ' + value+'\n')
+            else:
+                fp.write(name+'  ' + value+'\n')
+    else:
+        fp.write(name+'\n')
+
+
+# Refactored over here to allow access by GSASIIscriptable.py
+def WriteAtomsNuclear(fp, phasedict, phasenam, parmDict, sigDict, labellist):
+    'Write atom positions to CIF'
+    # phasedict = self.Phases[phasenam] # pointer to current phase info
+    General = phasedict['General']
+    cx,ct,cs,cia = General['AtomPtrs']
+    Atoms = phasedict['Atoms']
+    cfrac = cx+3
+    fpfx = str(phasedict['pId'])+'::Afrac:'
+    for i,at in enumerate(Atoms):
+        fval = parmDict.get(fpfx+str(i),at[cfrac])
+        if fval != 0.0:
+            break
+    else:
+        WriteCIFitem(fp, '\n# PHASE HAS NO ATOMS!')
+        return
+
+    WriteCIFitem(fp, '\n# ATOMIC COORDINATES AND DISPLACEMENT PARAMETERS')
+    WriteCIFitem(fp, 'loop_ '+
+                 '\n   _atom_site_label'+
+                 '\n   _atom_site_type_symbol'+
+                 '\n   _atom_site_fract_x'+
+                 '\n   _atom_site_fract_y'+
+                 '\n   _atom_site_fract_z'+
+                 '\n   _atom_site_occupancy'+
+                 '\n   _atom_site_adp_type'+
+                 '\n   _atom_site_U_iso_or_equiv'+
+                 '\n   _atom_site_symmetry_multiplicity')
+
+    varnames = {cx:'Ax',cx+1:'Ay',cx+2:'Az',cx+3:'Afrac',
+                cia+1:'AUiso',cia+2:'AU11',cia+3:'AU22',cia+4:'AU33',
+                cia+5:'AU12',cia+6:'AU13',cia+7:'AU23'}
+    # Empty the labellist
+    while labellist:
+        labellist.pop()
+
+    pfx = str(phasedict['pId'])+'::'
+    # loop over all atoms
+    naniso = 0
+    for i,at in enumerate(Atoms):
+        if phasedict['General']['Type'] == 'macromolecular':
+            label = '%s_%s_%s_%s'%(at[ct-1],at[ct-3],at[ct-4],at[ct-2])
+            s = PutInCol(MakeUniqueLabel(label,labellist),15) # label
+        else:
+            s = PutInCol(MakeUniqueLabel(at[ct-1],labellist),6) # label
+        fval = parmDict.get(fpfx+str(i),at[cfrac])
+        if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
+        s += PutInCol(FmtAtomType(at[ct]),4) # type
+        if at[cia] == 'I':
+            adp = 'Uiso '
+        else:
+            adp = 'Uani '
+            naniso += 1
+            # compute Uequiv crudely
+            # correct: Defined as "1/3 trace of diagonalized U matrix".
+            # SEE cell2GS & Uij2Ueqv to GSASIIlattice. Former is needed to make the GS matrix used by the latter.
+            t = 0.0
+            for j in (2,3,4):
+                var = pfx+varnames[cia+j]+":"+str(i)
+                t += parmDict.get(var,at[cia+j])
+        for j in (cx,cx+1,cx+2,cx+3,cia,cia+1):
+            if j in (cx,cx+1,cx+2):
+                dig = 11
+                sigdig = -0.00009
+            else:
+                dig = 10
+                sigdig = -0.009
+            if j == cia:
+                s += adp
+            else:
+                var = pfx+varnames[j]+":"+str(i)
+                dvar = pfx+"d"+varnames[j]+":"+str(i)
+                if dvar not in sigDict:
+                    dvar = var
+                if j == cia+1 and adp == 'Uani ':
+                    val = t/3.
+                    sig = sigdig
+                else:
+                    #print var,(var in parmDict),(var in sigDict)
+                    val = parmDict.get(var,at[j])
+                    sig = sigDict.get(dvar,sigdig)
+                s += PutInCol(G2mth.ValEsd(val,sig),dig)
+        s += PutInCol(at[cs+1],3)
+        WriteCIFitem(fp, s)
+    if naniso == 0: return
+    # now loop over aniso atoms
+    WriteCIFitem(fp, '\nloop_' + '\n   _atom_site_aniso_label' +
+                 '\n   _atom_site_aniso_U_11' + '\n   _atom_site_aniso_U_22' +
+                 '\n   _atom_site_aniso_U_33' + '\n   _atom_site_aniso_U_12' +
+                 '\n   _atom_site_aniso_U_13' + '\n   _atom_site_aniso_U_23')
+    for i,at in enumerate(Atoms):
+        fval = parmDict.get(fpfx+str(i),at[cfrac])
+        if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
+        if at[cia] == 'I': continue
+        s = PutInCol(labellist[i],6) # label
+        for j in (2,3,4,5,6,7):
+            sigdig = -0.0009
+            var = pfx+varnames[cia+j]+":"+str(i)
+            val = parmDict.get(var,at[cia+j])
+            sig = sigDict.get(var,sigdig)
+            s += PutInCol(G2mth.ValEsd(val,sig),11)
+        WriteCIFitem(fp, s)
+
+
+# Refactored over here to allow access by GSASIIscriptable.py
+def MakeUniqueLabel(lbl, labellist):
+    lbl = lbl.strip()
+    if not lbl: # deal with a blank label
+        lbl = 'A_1'
+    if lbl not in labellist:
+        labellist.append(lbl)
+        return lbl
+    i = 1
+    prefix = lbl
+    if '_' in lbl:
+        prefix = lbl[:lbl.rfind('_')]
+        suffix = lbl[lbl.rfind('_')+1:]
+        try:
+            i = int(suffix)+1
+        except:
+            pass
+    while prefix+'_'+str(i) in labellist:
+        i += 1
+    else:
+        lbl = prefix+'_'+str(i)
+        labellist.append(lbl)
+
+
+# Refactored over here to allow access by GSASIIscriptable.py
+def FmtAtomType(sym):
+    'Reformat a GSAS-II atom type symbol to match CIF rules'
+    sym = sym.replace('_','') # underscores are not allowed: no isotope designation?
+    # in CIF, oxidation state sign symbols come after, not before
+    if '+' in sym:
+        sym = sym.replace('+','') + '+'
+    elif '-' in sym:
+        sym = sym.replace('-','') + '-'
+    return sym
+
+
+# Refactored over here to allow access by GSASIIscriptable.py
+def PutInCol(val, wid):
+    val = str(val).replace(' ', '')
+    if not val: val = '?'
+    fmt = '{:' + str(wid) + '} '
+    return fmt.format(val)
+
+
+# Refactored over here to allow access by GSASIIscriptable.py
+def WriteComposition(fp, phasedict, phasenam, parmDict):
+    '''determine the composition for the unit cell, crudely determine Z and
+    then compute the composition in formula units
+    '''
+    General = phasedict['General']
+    Z = General.get('cellZ',0.0)
+    cx,ct,cs,cia = General['AtomPtrs']
+    Atoms = phasedict['Atoms']
+    fpfx = str(phasedict['pId'])+'::Afrac:'
+    cfrac = cx+3
+    cmult = cs+1
+    compDict = {} # combines H,D & T
+    sitemultlist = []
+    massDict = dict(zip(General['AtomTypes'],General['AtomMass']))
+    cellmass = 0
+    for i,at in enumerate(Atoms):
+        atype = at[ct].strip()
+        if atype.find('-') != -1: atype = atype.split('-')[0]
+        if atype.find('+') != -1: atype = atype.split('+')[0]
+        atype = atype[0].upper()+atype[1:2].lower() # force case conversion
+        if atype == "D" or atype == "D": atype = "H"
+        fvar = fpfx+str(i)
+        fval = parmDict.get(fvar,at[cfrac])
+        mult = at[cmult]
+        if not massDict.get(at[ct]):
+            print('Error: No mass found for atom type '+at[ct])
+            print('Will not compute cell contents for phase '+phasenam)
+            return
+        cellmass += massDict[at[ct]]*mult*fval
+        compDict[atype] = compDict.get(atype,0.0) + mult*fval
+        if fval == 1: sitemultlist.append(mult)
+    if len(compDict.keys()) == 0: return # no elements!
+    if Z < 1: # Z has not been computed or set by user
+        Z = 1
+        if not sitemultlist:
+            General['cellZ'] = 1
+            return
+        for i in range(2,min(sitemultlist)+1):
+            for m in sitemultlist:
+                if m % i != 0:
+                    break
+                else:
+                    Z = i
+        General['cellZ'] = Z # save it
+
+    # when scattering factors are included in the CIF, this needs to be
+    # added to the loop here but only in the one-block case.
+    # For multiblock CIFs, scattering factors go in the histogram
+    # blocks  (for all atoms in all appropriate phases) - an example?:
+    #loop_
+    #    _atom_type_symbol
+    #    _atom_type_description
+    #    _atom_type_scat_dispersion_real
+    #    _atom_type_scat_dispersion_imag
+    #    _atom_type_scat_source
+    #    'C' 'C' 0.0033 0.0016
+    #                         'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
+    #    'H' 'H' 0.0000 0.0000
+    #                         'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
+    #    'P' 'P' 0.1023 0.0942
+    #                         'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
+    #    'Cl' 'Cl' 0.1484 0.1585
+    #                         'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
+    #    'Cu' 'Cu' 0.3201 1.2651
+    #                         'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
+
+    #if oneblock: # add scattering factors for current phase here
+    WriteCIFitem(fp, '\nloop_  _atom_type_symbol _atom_type_number_in_cell')
+    formula = ''
+    reload(G2mth)
+    for elem in HillSortElements(compDict.keys()):
+        WriteCIFitem(fp, '  ' + PutInCol(elem,4) +
+                     G2mth.ValEsd(compDict[elem],-0.009,True))
+        if formula: formula += " "
+        formula += elem
+        if compDict[elem] == Z: continue
+        formula += G2mth.ValEsd(compDict[elem]/Z,-0.009,True)
+    WriteCIFitem(fp,  '\n# Note that Z affects _cell_formula_sum and _weight')
+    WriteCIFitem(fp,  '_cell_formula_units_Z',str(Z))
+    WriteCIFitem(fp,  '_chemical_formula_sum',formula)
+    WriteCIFitem(fp,  '_chemical_formula_weight',
+                  G2mth.ValEsd(cellmass/Z,-0.09,True))
+
 class ExportCIF(G2IO.ExportBaseclass):
     '''Base class for CIF exports
@@ -64 +320 @@
                              'Unicode not valid for CIF')
             return True
-                      
+
     def _Exporter(self,event=None,phaseOnly=None,histOnly=None,IncludeOnlyHist=None):
         '''Basic code to export a CIF. Export can be full or simple, as set by
@@ -76 +332 @@
 
 #***** define functions for export method =======================================
-        def WriteCIFitem(name,value=''):
-            '''Write CIF data items to the file. Formats values as needed.
-            Also used without a value for loops, comments, loop headers, etc.
-            '''
-            if all(ord(c) < 128 for c in value) and all(ord(c) < 128 for c in name):
-                pass
-            else:
-                print('Warning: unicode stripped from CIF item with name='+name+' value='+value)
-                s = ''
-                for c in name:
-                    if ord(c) < 128:
-                        s += c
-                    else:
-                        s += '.'
-                name = s
-                s = ''
-                for c in value:
-                    if ord(c) < 128:
-                        s += c
-                    else:
-                        s += '.'
-                value = s
-                print('...changed to name='+name+' value='+value)
-                
-            if value:
-                if "\n" in value or len(value)> 70:
-                    if name.strip(): self.fp.write(name+'\n')
-                    self.fp.write('; '+value+'\n')
-                    self.fp.write('; '+'\n')
-                elif " " in value:
-                    if len(name)+len(value) > 65:
-                        self.fp.write(name + '\n   ' + '"' + str(value) + '"'+'\n')
-                    else:
-                        self.fp.write(name + '  ' + '"' + str(value) + '"'+'\n')
-                else:
-                    if len(name)+len(value) > 65:
-                        self.fp.write(name+'\n   ' + value+'\n')
-                    else:
-                        self.fp.write(name+'  ' + value+'\n')
-            else:
-                self.fp.write(name+'\n')
-
         def WriteAudit():
             'Write the CIF audit values. Perhaps should be in a single element loop.'
-            WriteCIFitem('_audit_creation_method',
+            WriteCIFitem(self.fp, '_audit_creation_method',
                          'created in GSAS-II')
-            WriteCIFitem('_audit_creation_date',self.CIFdate)
+            WriteCIFitem(self.fp, '_audit_creation_date',self.CIFdate)
             if self.author:
-                WriteCIFitem('_audit_author_name',self.author)
-            WriteCIFitem('_audit_update_record',
+                WriteCIFitem(self.fp, '_audit_author_name',self.author)
+            WriteCIFitem(self.fp, '_audit_update_record',
                          self.CIFdate+'  Initial software-generated CIF')
 
@@ -134 +348 @@
             '''
             if self.ifPWDR:
-                WriteCIFitem('_pd_proc_info_datetime', self.CIFdate)
-                WriteCIFitem('_pd_calc_method', 'Rietveld Refinement')
-            #WriteCIFitem('_refine_ls_shift/su_max',DAT1)
-            #WriteCIFitem('_refine_ls_shift/su_mean',DAT2)
-            WriteCIFitem('_computing_structure_refinement','GSAS-II (Toby & Von Dreele, J. Appl. Cryst. 46, 544-549, 2013)')
+                WriteCIFitem(self.fp, '_pd_proc_info_datetime', self.CIFdate)
+                WriteCIFitem(self.fp, '_pd_calc_method', 'Rietveld Refinement')
+            #WriteCIFitem(self.fp, '_refine_ls_shift/su_max',DAT1)
+            #WriteCIFitem(self.fp, '_refine_ls_shift/su_mean',DAT2)
+            WriteCIFitem(self.fp, '_computing_structure_refinement','GSAS-II (Toby & Von Dreele, J. Appl. Cryst. 46, 544-549, 2013)')
             if self.ifHKLF:
                 controls = self.OverallParms['Controls']
@@ -145 +359 @@
                 else:
                     thresh = 'F>%.1fu(F)'%(controls['minF/sig'])
-                WriteCIFitem('_reflns_threshold_expression', thresh)                
+                WriteCIFitem(self.fp, '_reflns_threshold_expression', thresh)
             try:
                 vars = str(len(self.OverallParms['Covariance']['varyList']))
             except:
                 vars = '?'
-            WriteCIFitem('_refine_ls_number_parameters',vars)
+            WriteCIFitem(self.fp, '_refine_ls_number_parameters',vars)
             try:
                 GOF = G2mth.ValEsd(self.OverallParms['Covariance']['Rvals']['GOF'],-0.009)
             except:
                 GOF = '?'
-            WriteCIFitem('_refine_ls_goodness_of_fit_all',GOF)
+            WriteCIFitem(self.fp, '_refine_ls_goodness_of_fit_all',GOF)
 
             # get restraint info
@@ -163 +377 @@
             #     for j in self.OverallParms['Constraints'][i]:
             #         print j
-            #WriteCIFitem('_refine_ls_number_restraints',TEXT)
+            #WriteCIFitem(self.fp, '_refine_ls_number_restraints',TEXT)
             # other things to consider reporting
             # _refine_ls_number_reflns
@@ -173 +387 @@
             # include an overall profile r-factor, if there is more than one powder histogram
             R = '%.5f'%(self.OverallParms['Covariance']['Rvals']['Rwp']/100.)
-            WriteCIFitem('\n# OVERALL WEIGHTED R-FACTOR')
-            WriteCIFitem('_refine_ls_wR_factor_obs',R)
+            WriteCIFitem(self.fp, '\n# OVERALL WEIGHTED R-FACTOR')
+            WriteCIFitem(self.fp, '_refine_ls_wR_factor_obs',R)
                 # _refine_ls_R_factor_all
-                # _refine_ls_R_factor_obs                
-            WriteCIFitem('_refine_ls_matrix_type','full')
-            #WriteCIFitem('_refine_ls_matrix_type','userblocks')
+                # _refine_ls_R_factor_obs
+            WriteCIFitem(self.fp, '_refine_ls_matrix_type','full')
+            #WriteCIFitem(self.fp, '_refine_ls_matrix_type','userblocks')
 
         def writeCIFtemplate(G2dict,tmplate,defaultname=''):
             '''Write out the selected or edited CIF template
             An unedited CIF template file is copied, comments intact; an edited
-            CIF template is written out from PyCifRW which of course strips comments. 
+            CIF template is written out from PyCifRW which of course strips comments.
             In all cases the initial data_ header is stripped (there should only be one!)
             '''
@@ -221 +435 @@
             txt = "# GSAS-II edited template follows "+txt[txt.index("data_")+5:]
             #txt = txt.replace('data_','#')
-            WriteCIFitem(txt)
+            WriteCIFitem(self.fp, txt)
 
         def FormatSH(phasenam):
             'Format a full spherical harmonics texture description as a string'
-            phasedict = self.Phases[phasenam] # pointer to current phase info            
+            phasedict = self.Phases[phasenam] # pointer to current phase info
             pfx = str(phasedict['pId'])+'::'
             s = ""
-            textureData = phasedict['General']['SH Texture']    
+            textureData = phasedict['General']['SH Texture']
             if textureData.get('Order'):
                 s += "Spherical Harmonics correction. Order = "+str(textureData['Order'])
@@ -257 +471 @@
             character string
             '''
-            phasedict = self.Phases[phasenam] # pointer to current phase info            
+            phasedict = self.Phases[phasenam] # pointer to current phase info
             s = ''
             for histogram in sorted(phasedict['Histograms']):
@@ -292 +506 @@
                     s += s1
             return s
-        
+
         def FormatBackground(bkg,hId):
             '''Display the Background information as a descriptive text string.
-            
+
             TODO: this needs to be expanded to show the diffuse peak and
             Debye term information as well. (Bob)
@@ -349 +563 @@
                     name = hfx+item
                     sig = self.sigDict.get(name,-0.009)
-                    s += G2mth.ValEsd(inst[item][1],sig)+', '                    
+                    s += G2mth.ValEsd(inst[item][1],sig)+', '
             elif 'T' in inst['Type'][0]:    #to be tested after TOF Rietveld done
                 s = 'Von Dreele-Jorgenson-Windsor function parameters\n'+ \
@@ -367 +581 @@
             s = ''
             phasedict = self.Phases[phasenam] # pointer to current phase info
-            SGData = phasedict['General'] ['SGData']          
+            SGData = phasedict['General'] ['SGData']
             for histogram in sorted(phasedict['Histograms']):
                 if histogram.startswith("HKLF"): continue # powder only
@@ -387 +601 @@
                 else:
                     s += '  Crystallite size model "%s" for %s (microns)\n  '%(size[0],phasenam)
-                
+
                 names = ['Size;i','Size;mx']
                 if 'uniax' in size[0]:
@@ -404 +618 @@
                         s += G2mth.ValEsd(size[4][i],sig)+', '
                     sig = self.sigDict.get(phfx+'Size;mx',-0.009)
-                    s += G2mth.ValEsd(size[1][2],sig)+', '                                           
+                    s += G2mth.ValEsd(size[1][2],sig)+', '
                 else:       #isotropic
                     s += 'parameters: Size, G/L mix\n    '
@@ -412 +626 @@
                         sig = self.sigDict.get(name,-0.009)
                         s += G2mth.ValEsd(size[1][i],sig)+', '
-                        i = 2    #skip the aniso value                
+                        i = 2    #skip the aniso value
                 s += '\n  Mustrain model "%s" for %s (10^6^)\n  '%(mustrain[0],phasenam)
                 names = ['Mustrain;i','Mustrain;mx']
@@ -439 +653 @@
                             txt = ''
                         txt += G2mth.ValEsd(mustrain[4][i],sig)+', '
-                    s += txt                                           
+                    s += txt
                     sig = self.sigDict.get(phfx+'Mustrain;mx',-0.009)
                     s += G2mth.ValEsd(mustrain[1][2],sig)+', '
-                    
+
                 else:       #isotropic
                     s += '  parameters: Mustrain, G/L mix\n    '
@@ -450 +664 @@
                         sig = self.sigDict.get(name,-0.009)
                         s += G2mth.ValEsd(mustrain[1][i],sig)+', '
-                        i = 2    #skip the aniso value                
+                        i = 2    #skip the aniso value
                 s1 = '  \n  Macrostrain parameters: '
                 names = G2spc.HStrainNames(SGData)
@@ -468 +682 @@
                     s += '\n'
             return s
-        
-        def FmtAtomType(sym):
-            'Reformat a GSAS-II atom type symbol to match CIF rules'
-            sym = sym.replace('_','') # underscores are not allowed: no isotope designation?
-            # in CIF, oxidation state sign symbols come after, not before
-            if '+' in sym:
-                sym = sym.replace('+','') + '+'
-            elif '-' in sym:
-                sym = sym.replace('-','') + '-'
-            return sym
-            
-        def PutInCol(val,wid):
-            '''Pad a value to >=wid+1 columns by adding spaces at the end. Always
-            adds at least one space
-            '''
-            val = str(val).replace(' ','')
-            if not val: val = '?'
-            fmt = '{:' + str(wid) + '} '
-            return fmt.format(val)
 
         def MakeUniqueLabel(lbl,labellist):
@@ -511 +706 @@
                 labellist.append(lbl)
 
-        def WriteAtomsNuclear(phasenam):
-            'Write atom positions to CIF'
-            phasedict = self.Phases[phasenam] # pointer to current phase info
-            General = phasedict['General']
-            cx,ct,cs,cia = General['AtomPtrs']
-            Atoms = phasedict['Atoms']
-            cfrac = cx+3
-            fpfx = str(phasedict['pId'])+'::Afrac:'        
-            for i,at in enumerate(Atoms):
-                fval = self.parmDict.get(fpfx+str(i),at[cfrac])
-                if fval != 0.0:
-                    break
-            else:
-                WriteCIFitem('\n# PHASE HAS NO ATOMS!')
-                return
-                
-            WriteCIFitem('\n# ATOMIC COORDINATES AND DISPLACEMENT PARAMETERS')
-            WriteCIFitem('loop_ '+
-                         '\n   _atom_site_label'+
-                         '\n   _atom_site_type_symbol'+
-                         '\n   _atom_site_fract_x'+
-                         '\n   _atom_site_fract_y'+
-                         '\n   _atom_site_fract_z'+
-                         '\n   _atom_site_occupancy'+
-                         '\n   _atom_site_adp_type'+
-                         '\n   _atom_site_U_iso_or_equiv'+
-                         '\n   _atom_site_symmetry_multiplicity')
-
-            varnames = {cx:'Ax',cx+1:'Ay',cx+2:'Az',cx+3:'Afrac',
-                        cia+1:'AUiso',cia+2:'AU11',cia+3:'AU22',cia+4:'AU33',
-                        cia+5:'AU12',cia+6:'AU13',cia+7:'AU23'}
-            self.labellist = []
-            
-            pfx = str(phasedict['pId'])+'::'
-            # loop over all atoms
-            naniso = 0
-            for i,at in enumerate(Atoms):
-                if phasedict['General']['Type'] == 'macromolecular':
-                    label = '%s_%s_%s_%s'%(at[ct-1],at[ct-3],at[ct-4],at[ct-2])
-                    s = PutInCol(MakeUniqueLabel(label,self.labellist),15) # label
-                else:
-                    s = PutInCol(MakeUniqueLabel(at[ct-1],self.labellist),6) # label
-                fval = self.parmDict.get(fpfx+str(i),at[cfrac])
-                if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
-                s += PutInCol(FmtAtomType(at[ct]),4) # type
-                if at[cia] == 'I':
-                    adp = 'Uiso '
-                else:
-                    adp = 'Uani '
-                    naniso += 1
-                    # compute Uequiv crudely
-                    # correct: Defined as "1/3 trace of diagonalized U matrix".
-                    # SEE cell2GS & Uij2Ueqv to GSASIIlattice. Former is needed to make the GS matrix used by the latter.
-                    t = 0.0
-                    for j in (2,3,4):
-                        var = pfx+varnames[cia+j]+":"+str(i)
-                        t += self.parmDict.get(var,at[cia+j])
-                for j in (cx,cx+1,cx+2,cx+3,cia,cia+1):
-                    if j in (cx,cx+1,cx+2):
-                        dig = 11
-                        sigdig = -0.00009
-                    else:
-                        dig = 10
-                        sigdig = -0.009
-                    if j == cia:
-                        s += adp
-                    else:
-                        var = pfx+varnames[j]+":"+str(i)
-                        dvar = pfx+"d"+varnames[j]+":"+str(i)
-                        if dvar not in self.sigDict:
-                            dvar = var
-                        if j == cia+1 and adp == 'Uani ':
-                            val = t/3.
-                            sig = sigdig
-                        else:
-                            #print var,(var in self.parmDict),(var in self.sigDict)
-                            val = self.parmDict.get(var,at[j])
-                            sig = self.sigDict.get(dvar,sigdig)
-                        s += PutInCol(G2mth.ValEsd(val,sig),dig)
-                s += PutInCol(at[cs+1],3)
-                WriteCIFitem(s)
-            if naniso == 0: return
-            # now loop over aniso atoms
-            WriteCIFitem('\nloop_' + '\n   _atom_site_aniso_label' + 
-                         '\n   _atom_site_aniso_U_11' + '\n   _atom_site_aniso_U_22' +
-                         '\n   _atom_site_aniso_U_33' + '\n   _atom_site_aniso_U_12' +
-                         '\n   _atom_site_aniso_U_13' + '\n   _atom_site_aniso_U_23')
-            for i,at in enumerate(Atoms):
-                fval = self.parmDict.get(fpfx+str(i),at[cfrac])
-                if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
-                if at[cia] == 'I': continue
-                s = PutInCol(self.labellist[i],6) # label
-                for j in (2,3,4,5,6,7):
-                    sigdig = -0.0009
-                    var = pfx+varnames[cia+j]+":"+str(i)
-                    val = self.parmDict.get(var,at[cia+j])
-                    sig = self.sigDict.get(var,sigdig)
-                    s += PutInCol(G2mth.ValEsd(val,sig),11)
-                WriteCIFitem(s)
+        # Factored out to above by Jack O'Donnell, so it
+        # could be accessed by GSASIIscriptable.py
+        #  def WriteAtomsNuclear(phasenam):
+        #      'Write atom positions to CIF'
+        #      phasedict = self.Phases[phasenam] # pointer to current phase info
+        #      General = phasedict['General']
+        #      cx,ct,cs,cia = General['AtomPtrs']
+        #      Atoms = phasedict['Atoms']
+        #      cfrac = cx+3
+        #      fpfx = str(phasedict['pId'])+'::Afrac:'
+        #      for i,at in enumerate(Atoms):
+        #          fval = self.parmDict.get(fpfx+str(i),at[cfrac])
+        #          if fval != 0.0:
+        #              break
+        #      else:
+        #          WriteCIFitem(self.fp, '\n# PHASE HAS NO ATOMS!')
+        #          return
+
+        #      WriteCIFitem(self.fp, '\n# ATOMIC COORDINATES AND DISPLACEMENT PARAMETERS')
+        #      WriteCIFitem(self.fp, 'loop_ '+
+        #                   '\n   _atom_site_label'+
+        #                   '\n   _atom_site_type_symbol'+
+        #                   '\n   _atom_site_fract_x'+
+        #                   '\n   _atom_site_fract_y'+
+        #                   '\n   _atom_site_fract_z'+
+        #                   '\n   _atom_site_occupancy'+
+        #                   '\n   _atom_site_adp_type'+
+        #                   '\n   _atom_site_U_iso_or_equiv'+
+        #                   '\n   _atom_site_symmetry_multiplicity')
+
+        #      varnames = {cx:'Ax',cx+1:'Ay',cx+2:'Az',cx+3:'Afrac',
+        #                  cia+1:'AUiso',cia+2:'AU11',cia+3:'AU22',cia+4:'AU33',
+        #                  cia+5:'AU12',cia+6:'AU13',cia+7:'AU23'}
+        #      self.labellist = []
+
+        #      pfx = str(phasedict['pId'])+'::'
+        #      # loop over all atoms
+        #      naniso = 0
+        #      for i,at in enumerate(Atoms):
+        #          if phasedict['General']['Type'] == 'macromolecular':
+        #              label = '%s_%s_%s_%s'%(at[ct-1],at[ct-3],at[ct-4],at[ct-2])
+        #              s = PutInCol(MakeUniqueLabel(label,self.labellist),15) # label
+        #          else:
+        #              s = PutInCol(MakeUniqueLabel(at[ct-1],self.labellist),6) # label
+        #          fval = self.parmDict.get(fpfx+str(i),at[cfrac])
+        #          if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
+        #          s += PutInCol(FmtAtomType(at[ct]),4) # type
+        #          if at[cia] == 'I':
+        #              adp = 'Uiso '
+        #          else:
+        #              adp = 'Uani '
+        #              naniso += 1
+        #              # compute Uequiv crudely
+        #              # correct: Defined as "1/3 trace of diagonalized U matrix".
+        #              # SEE cell2GS & Uij2Ueqv to GSASIIlattice. Former is needed to make the GS matrix used by the latter.
+        #              t = 0.0
+        #              for j in (2,3,4):
+        #                  var = pfx+varnames[cia+j]+":"+str(i)
+        #                  t += self.parmDict.get(var,at[cia+j])
+        #          for j in (cx,cx+1,cx+2,cx+3,cia,cia+1):
+        #              if j in (cx,cx+1,cx+2):
+        #                  dig = 11
+        #                  sigdig = -0.00009
+        #              else:
+        #                  dig = 10
+        #                  sigdig = -0.009
+        #              if j == cia:
+        #                  s += adp
+        #              else:
+        #                  var = pfx+varnames[j]+":"+str(i)
+        #                  dvar = pfx+"d"+varnames[j]+":"+str(i)
+        #                  if dvar not in self.sigDict:
+        #                      dvar = var
+        #                  if j == cia+1 and adp == 'Uani ':
+        #                      val = t/3.
+        #                      sig = sigdig
+        #                  else:
+        #                      #print var,(var in self.parmDict),(var in self.sigDict)
+        #                      val = self.parmDict.get(var,at[j])
+        #                      sig = self.sigDict.get(dvar,sigdig)
+        #                  s += PutInCol(G2mth.ValEsd(val,sig),dig)
+        #          s += PutInCol(at[cs+1],3)
+        #          WriteCIFitem(self.fp, s)
+        #      if naniso == 0: return
+        #      # now loop over aniso atoms
+        #      WriteCIFitem(self.fp, '\nloop_' + '\n   _atom_site_aniso_label' +
+        #                   '\n   _atom_site_aniso_U_11' + '\n   _atom_site_aniso_U_22' +
+        #                   '\n   _atom_site_aniso_U_33' + '\n   _atom_site_aniso_U_12' +
+        #                   '\n   _atom_site_aniso_U_13' + '\n   _atom_site_aniso_U_23')
+        #      for i,at in enumerate(Atoms):
+        #          fval = self.parmDict.get(fpfx+str(i),at[cfrac])
+        #          if fval == 0.0: continue # ignore any atoms that have a occupancy set to 0 (exact)
+        #          if at[cia] == 'I': continue
+        #          s = PutInCol(self.labellist[i],6) # label
+        #          for j in (2,3,4,5,6,7):
+        #              sigdig = -0.0009
+        #              var = pfx+varnames[cia+j]+":"+str(i)
+        #              val = self.parmDict.get(var,at[cia+j])
+        #              sig = self.sigDict.get(var,sigdig)
+        #              s += PutInCol(G2mth.ValEsd(val,sig),11)
+        #          WriteCIFitem(self.fp, s)
 
         def HillSortElements(elmlist):
@@ -627 +824 @@
             return newlist+sorted(oldlist)
 
-        def WriteComposition(phasenam):
-            '''determine the composition for the unit cell, crudely determine Z and
-            then compute the composition in formula units
-            '''
-            phasedict = self.Phases[phasenam] # pointer to current phase info
-            General = phasedict['General']
-            Z = General.get('cellZ',0.0)
-            cx,ct,cs,cia = General['AtomPtrs']
-            Atoms = phasedict['Atoms']
-            fpfx = str(phasedict['pId'])+'::Afrac:'        
-            cfrac = cx+3
-            cmult = cs+1
-            compDict = {} # combines H,D & T
-            sitemultlist = []
-            massDict = dict(zip(General['AtomTypes'],General['AtomMass']))
-            cellmass = 0
-            for i,at in enumerate(Atoms):
-                atype = at[ct].strip()
-                if atype.find('-') != -1: atype = atype.split('-')[0]
-                if atype.find('+') != -1: atype = atype.split('+')[0]
-                atype = atype[0].upper()+atype[1:2].lower() # force case conversion
-                if atype == "D" or atype == "D": atype = "H"
-                fvar = fpfx+str(i)
-                fval = self.parmDict.get(fvar,at[cfrac])
-                mult = at[cmult]
-                if not massDict.get(at[ct]):
-                    print('Error: No mass found for atom type '+at[ct])
-                    print('Will not compute cell contents for phase '+phasenam)
-                    return
-                cellmass += massDict[at[ct]]*mult*fval
-                compDict[atype] = compDict.get(atype,0.0) + mult*fval
-                if fval == 1: sitemultlist.append(mult)
-            if len(compDict.keys()) == 0: return # no elements!
-            if Z < 1: # Z has not been computed or set by user
-                Z = 1
-                if not sitemultlist: 
-                    General['cellZ'] = 1
-                    return
-                for i in range(2,min(sitemultlist)+1):
-                    for m in sitemultlist:
-                        if m % i != 0:
-                            break
-                        else:
-                            Z = i
-                General['cellZ'] = Z # save it
-
-            # when scattering factors are included in the CIF, this needs to be
-            # added to the loop here but only in the one-block case.
-            # For multiblock CIFs, scattering factors go in the histogram
-            # blocks  (for all atoms in all appropriate phases) - an example?:
+        # Factored out to above by Jackson O'Donnell
+        # so that it can be accessed by GSASIIscriptable
+
+        # def WriteComposition(phasenam):
+        #     '''determine the composition for the unit cell, crudely determine Z and
+        #     then compute the composition in formula units
+        #     '''
+        #     phasedict = self.Phases[phasenam] # pointer to current phase info
+        #     General = phasedict['General']
+        #     Z = General.get('cellZ',0.0)
+        #     cx,ct,cs,cia = General['AtomPtrs']
+        #     Atoms = phasedict['Atoms']
+        #     fpfx = str(phasedict['pId'])+'::Afrac:'
+        #     cfrac = cx+3
+        #     cmult = cs+1
+        #     compDict = {} # combines H,D & T
+        #     sitemultlist = []
+        #     massDict = dict(zip(General['AtomTypes'],General['AtomMass']))
+        #     cellmass = 0
+        #     for i,at in enumerate(Atoms):
+        #         atype = at[ct].strip()
+        #         if atype.find('-') != -1: atype = atype.split('-')[0]
+        #         if atype.find('+') != -1: atype = atype.split('+')[0]
+        #         atype = atype[0].upper()+atype[1:2].lower() # force case conversion
+        #         if atype == "D" or atype == "D": atype = "H"
+        #         fvar = fpfx+str(i)
+        #         fval = self.parmDict.get(fvar,at[cfrac])
+        #         mult = at[cmult]
+        #         if not massDict.get(at[ct]):
+        #             print('Error: No mass found for atom type '+at[ct])
+        #             print('Will not compute cell contents for phase '+phasenam)
+        #             return
+        #         cellmass += massDict[at[ct]]*mult*fval
+        #         compDict[atype] = compDict.get(atype,0.0) + mult*fval
+        #         if fval == 1: sitemultlist.append(mult)
+        #     if len(compDict.keys()) == 0: return # no elements!
+        #     if Z < 1: # Z has not been computed or set by user
+        #         Z = 1
+        #         if not sitemultlist:
+        #             General['cellZ'] = 1
+        #             return
+        #         for i in range(2,min(sitemultlist)+1):
+        #             for m in sitemultlist:
+        #                 if m % i != 0:
+        #                     break
+        #                 else:
+        #                     Z = i
+        #         General['cellZ'] = Z # save it
+
+        #     # when scattering factors are included in the CIF, this needs to be
+        #     # added to the loop here but only in the one-block case.
+        #     # For multiblock CIFs, scattering factors go in the histogram
+        #     # blocks  (for all atoms in all appropriate phases) - an example?:
 #loop_
-#    _atom_type_symbol
-#    _atom_type_description
-#    _atom_type_scat_dispersion_real
-#    _atom_type_scat_dispersion_imag
-#    _atom_type_scat_source
-#    'C' 'C' 0.0033 0.0016
-#                         'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
-#    'H' 'H' 0.0000 0.0000
-#                         'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
-#    'P' 'P' 0.1023 0.0942
-#                         'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
-#    'Cl' 'Cl' 0.1484 0.1585
-#                         'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
-#    'Cu' 'Cu' 0.3201 1.2651
-#                         'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
-
-            #if oneblock: # add scattering factors for current phase here
-            WriteCIFitem('\nloop_  _atom_type_symbol _atom_type_number_in_cell')
-            formula = ''
-            reload(G2mth)
-            for elem in HillSortElements(compDict.keys()):
-                WriteCIFitem('  ' + PutInCol(elem,4) +
-                             G2mth.ValEsd(compDict[elem],-0.009,True))
-                if formula: formula += " "
-                formula += elem
-                if compDict[elem] == Z: continue
-                formula += G2mth.ValEsd(compDict[elem]/Z,-0.009,True)
-            WriteCIFitem( '\n# Note that Z affects _cell_formula_sum and _weight')
-            WriteCIFitem( '_cell_formula_units_Z',str(Z))
-            WriteCIFitem( '_chemical_formula_sum',formula)
-            WriteCIFitem( '_chemical_formula_weight',
-                          G2mth.ValEsd(cellmass/Z,-0.09,True))
+#    _at# om_type_symbol
+#    _at# om_type_description
+#    _at# om_type_scat_dispersion_real
+#    _at# om_type_scat_dispersion_imag
+#    _at# om_type_scat_source
+#    'C'#  'C' 0.0033 0.0016
+#       #                   'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
+#    'H'#  'H' 0.0000 0.0000
+#       #                   'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
+#    'P'#  'P' 0.1023 0.0942
+#       #                   'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
+#    'Cl# ' 'Cl' 0.1484 0.1585
+#       #                   'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
+#    'Cu# ' 'Cu' 0.3201 1.2651
+#       #                   'International Tables Vol C Tables 4.2.6.8 and 6.1.1.4'
+
+        #     #if oneblock: # add scattering factors for current phase here
+        #     WriteCIFitem(self.fp, '\nloop_  _atom_type_symbol _atom_type_number_in_cell')
+        #     formula = ''
+        #     reload(G2mth)
+        #     for elem in HillSortElements(compDict.keys()):
+        #         WriteCIFitem(self.fp, '  ' + PutInCol(elem,4) +
+        #                      G2mth.ValEsd(compDict[elem],-0.009,True))
+        #         if formula: formula += " "
+        #         formula += elem
+        #         if compDict[elem] == Z: continue
+        #         formula += G2mth.ValEsd(compDict[elem]/Z,-0.009,True)
+        #     WriteCIFitem(self.fp,  '\n# Note that Z affects _cell_formula_sum and _weight')
+        #     WriteCIFitem(self.fp,  '_cell_formula_units_Z',str(Z))
+        #     WriteCIFitem(self.fp,  '_chemical_formula_sum',formula)
+        #     WriteCIFitem(self.fp,  '_chemical_formula_weight',
+        #                   G2mth.ValEsd(cellmass/Z,-0.09,True))
 
         def WriteDistances(phasenam,SymOpList,offsetList,symOpList,G2oprList):
@@ -722 +922 @@
             TODO: need a method to select publication flags for distances/angles
             '''
-            phasedict = self.Phases[phasenam] # pointer to current phase info            
+            phasedict = self.Phases[phasenam] # pointer to current phase info
             Atoms = phasedict['Atoms']
             generalData = phasedict['General']
@@ -731 +931 @@
             cx,ct,cs,cia = phasedict['General']['AtomPtrs']
             cn = ct-1
-            fpfx = str(phasedict['pId'])+'::Afrac:'        
+            fpfx = str(phasedict['pId'])+'::Afrac:'
             cfrac = cx+3
             DisAglData = {}
             # create a list of atoms, but skip atoms with zero occupancy
             xyz = []
-            fpfx = str(phasedict['pId'])+'::Afrac:'        
+            fpfx = str(phasedict['pId'])+'::Afrac:'
             for i,atom in enumerate(Atoms):
                 if self.parmDict.get(fpfx+str(i),atom[cfrac]) == 0.0: continue
@@ -776 +976 @@
             except KeyError:        # inside DistAngle for missing atom types in DisAglCtls
                 print('**** ERROR - try again but do "Reset" to fill in missing atom types ****')
-                    
+
             # loop over interatomic distances for this phase
-            WriteCIFitem('\n# MOLECULAR GEOMETRY')
-            WriteCIFitem('loop_' + 
+            WriteCIFitem(self.fp, '\n# MOLECULAR GEOMETRY')
+            WriteCIFitem(self.fp, 'loop_' +
                          '\n   _geom_bond_atom_site_label_1' +
-                         '\n   _geom_bond_atom_site_label_2' + 
-                         '\n   _geom_bond_distance' + 
-                         '\n   _geom_bond_site_symmetry_1' + 
-                         '\n   _geom_bond_site_symmetry_2' + 
+                         '\n   _geom_bond_atom_site_label_2' +
+                         '\n   _geom_bond_distance' +
+                         '\n   _geom_bond_site_symmetry_1' +
+                         '\n   _geom_bond_site_symmetry_2' +
                          '\n   _geom_bond_publ_flag')
 
@@ -802 +1002 @@
                     else:
                         line += " yes"
-                    WriteCIFitem(line)
+                    WriteCIFitem(self.fp, line)
 
             # loop over interatomic angles for this phase
-            WriteCIFitem('\nloop_' + 
-                         '\n   _geom_angle_atom_site_label_1' + 
-                         '\n   _geom_angle_atom_site_label_2' + 
-                         '\n   _geom_angle_atom_site_label_3' + 
-                         '\n   _geom_angle' + 
+            WriteCIFitem(self.fp, '\nloop_' +
+                         '\n   _geom_angle_atom_site_label_1' +
+                         '\n   _geom_angle_atom_site_label_2' +
+                         '\n   _geom_angle_atom_site_label_3' +
+                         '\n   _geom_angle' +
                          '\n   _geom_angle_site_symmetry_1' +
-                         '\n   _geom_angle_site_symmetry_2' + 
-                         '\n   _geom_angle_site_symmetry_3' + 
+                         '\n   _geom_angle_site_symmetry_2' +
+                         '\n   _geom_angle_site_symmetry_3' +
                          '\n   _geom_angle_publ_flag')
 
@@ -836 +1036 @@
                     else:
                         line += " yes"
-                    WriteCIFitem(line)
+                    WriteCIFitem(self.fp, line)
 
         def WritePhaseInfo(phasenam,hist=None):
             'Write out the phase information for the selected phase'
-            WriteCIFitem('\n# phase info for '+str(phasenam) + ' follows')
-            phasedict = self.Phases[phasenam] # pointer to current phase info            
-            WriteCIFitem('_pd_phase_name', phasenam)
+            WriteCIFitem(self.fp, '\n# phase info for '+str(phasenam) + ' follows')
+            phasedict = self.Phases[phasenam] # pointer to current phase info
+            WriteCIFitem(self.fp, '_pd_phase_name', phasenam)
             cellList,cellSig = self.GetCell(phasenam)
             defsigL = 3*[-0.00001] + 3*[-0.001] + [-0.01] # significance to use when no sigma
@@ -855 +1055 @@
                 else:
                     txt = G2mth.ValEsd(val,min(defsig,prevsig),True)
-                WriteCIFitem('_cell_'+lbl,txt)
-                    
-            WriteCIFitem('_symmetry_cell_setting',
+                WriteCIFitem(self.fp, '_cell_'+lbl,txt)
+
+            WriteCIFitem(self.fp, '_symmetry_cell_setting',
                          phasedict['General']['SGData']['SGSys'])
 
@@ -863 +1063 @@
             # regularize capitalization and remove trailing H/R
             spacegroup = spacegroup[0].upper() + spacegroup[1:].lower().rstrip('rh ')
-            WriteCIFitem('_symmetry_space_group_name_H-M',spacegroup)
+            WriteCIFitem(self.fp, '_symmetry_space_group_name_H-M',spacegroup)
 
             # generate symmetry operations including centering and center of symmetry
             SymOpList,offsetList,symOpList,G2oprList,G2opcodes = G2spc.AllOps(
                 phasedict['General']['SGData'])
-            WriteCIFitem('loop_\n    _space_group_symop_id\n    _space_group_symop_operation_xyz')
+            WriteCIFitem(self.fp, 'loop_\n    _space_group_symop_id\n    _space_group_symop_operation_xyz')
             for i,op in enumerate(SymOpList,start=1):
-                WriteCIFitem('   {:3d}  {:}'.format(i,op.lower()))
+                WriteCIFitem(self.fp, '   {:3d}  {:}'.format(i,op.lower()))
 
             # loop over histogram(s) used in this phase
@@ -891 +1091 @@
 
                 if len(histlist) == 0:
-                    WriteCIFitem('# Note: phase has no associated data')
+                    WriteCIFitem(self.fp, '# Note: phase has no associated data')
 
             # report atom params
             if phasedict['General']['Type'] in ['nuclear','macromolecular']:        #this needs macromolecular variant, etc!
-                WriteAtomsNuclear(phasenam)
+                try:
+                    self.labellist
+                except AttributeError:
+                    self.labellist = []
+                WriteAtomsNuclear(self.fp, self.Phases[phasenam], phasenam,
+                                  self.parmDict, self.sigDict, self.labellist)
             else:
                 raise Exception,"no export for "+str(phasedict['General']['Type'])+" coordinates implemented"
             # report cell contents
-            WriteComposition(phasenam)
+            WriteComposition(self.fp, self.Phases[phasenam], phasenam, self.parmDict)
             if not self.quickmode and phasedict['General']['Type'] == 'nuclear':      # report distances and angles
                 WriteDistances(phasenam,SymOpList,offsetList,symOpList,G2oprList)
             if 'Map' in phasedict['General'] and 'minmax' in phasedict['General']['Map']:
-                WriteCIFitem('\n# Difference density results')
+                WriteCIFitem(self.fp, '\n# Difference density results')
                 MinMax = phasedict['General']['Map']['minmax']
-                WriteCIFitem('_refine_diff_density_max',G2mth.ValEsd(MinMax[0],-0.009))
-                WriteCIFitem('_refine_diff_density_min',G2mth.ValEsd(MinMax[1],-0.009))
-                
+                WriteCIFitem(self.fp, '_refine_diff_density_max',G2mth.ValEsd(MinMax[0],-0.009))
+                WriteCIFitem(self.fp, '_refine_diff_density_min',G2mth.ValEsd(MinMax[1],-0.009))
+
         def Yfmt(ndec,val):
             'Format intensity values'
@@ -913 +1118 @@
             out = out.rstrip('0')  # strip zeros to right of decimal
             return out.rstrip('.')  # and decimal place when not needed
-            
+
         def WriteReflStat(refcount,hklmin,hklmax,dmin,dmax,nRefSets=1):
             'Write reflection statistics'
-            WriteCIFitem('_reflns_number_total', str(refcount))
+            WriteCIFitem(self.fp, '_reflns_number_total', str(refcount))
             if hklmin is not None and nRefSets == 1: # hkl range has no meaning with multiple phases
-                WriteCIFitem('_reflns_limit_h_min', str(int(hklmin[0])))
-                WriteCIFitem('_reflns_limit_h_max', str(int(hklmax[0])))
-                WriteCIFitem('_reflns_limit_k_min', str(int(hklmin[1])))
-                WriteCIFitem('_reflns_limit_k_max', str(int(hklmax[1])))
-                WriteCIFitem('_reflns_limit_l_min', str(int(hklmin[2])))
-                WriteCIFitem('_reflns_limit_l_max', str(int(hklmax[2])))
+                WriteCIFitem(self.fp, '_reflns_limit_h_min', str(int(hklmin[0])))
+                WriteCIFitem(self.fp, '_reflns_limit_h_max', str(int(hklmax[0])))
+                WriteCIFitem(self.fp, '_reflns_limit_k_min', str(int(hklmin[1])))
+                WriteCIFitem(self.fp, '_reflns_limit_k_max', str(int(hklmax[1])))
+                WriteCIFitem(self.fp, '_reflns_limit_l_min', str(int(hklmin[2])))
+                WriteCIFitem(self.fp, '_reflns_limit_l_max', str(int(hklmax[2])))
             if hklmin is not None:
-                WriteCIFitem('_reflns_d_resolution_low  ', G2mth.ValEsd(dmax,-0.009))
-                WriteCIFitem('_reflns_d_resolution_high ', G2mth.ValEsd(dmin,-0.009))
+                WriteCIFitem(self.fp, '_reflns_d_resolution_low  ', G2mth.ValEsd(dmax,-0.009))
+                WriteCIFitem(self.fp, '_reflns_d_resolution_high ', G2mth.ValEsd(dmin,-0.009))
 
         def WritePowderData(histlbl):
@@ -934 +1139 @@
             hId = histblk['hId']
             pfx = ':' + str(hId) + ':'
-            
+
             if 'Lam1' in inst:
                 ratio = self.parmDict.get('I(L2)/I(L1)',inst['I(L2)/I(L1)'][1])
@@ -943 +1148 @@
                 slam2 = self.sigDict.get('Lam2',-0.00009)
                 # always assume Ka1 & Ka2 if two wavelengths are present
-                WriteCIFitem('_diffrn_radiation_type','K\\a~1,2~')
-                WriteCIFitem('loop_' + 
+                WriteCIFitem(self.fp, '_diffrn_radiation_type','K\\a~1,2~')
+                WriteCIFitem(self.fp, 'loop_' +
                              '\n   _diffrn_radiation_wavelength' +
-                             '\n   _diffrn_radiation_wavelength_wt' + 
+                             '\n   _diffrn_radiation_wavelength_wt' +
                              '\n   _diffrn_radiation_wavelength_id')
-                WriteCIFitem('  ' + PutInCol(G2mth.ValEsd(lam1,slam1),15)+
-                             PutInCol('1.0',15) + 
+                WriteCIFitem(self.fp, '  ' + PutInCol(G2mth.ValEsd(lam1,slam1),15)+
+                             PutInCol('1.0',15) +
                              PutInCol('1',5))
-                WriteCIFitem('  ' + PutInCol(G2mth.ValEsd(lam2,slam2),15)+
+                WriteCIFitem(self.fp, '  ' + PutInCol(G2mth.ValEsd(lam2,slam2),15)+
                              PutInCol(G2mth.ValEsd(ratio,sratio),15)+
-                             PutInCol('2',5))                
+                             PutInCol('2',5))
             elif 'Lam' in inst:
                 lam1 = self.parmDict.get('Lam',inst['Lam'][1])
                 slam1 = self.sigDict.get('Lam',-0.00009)
-                WriteCIFitem('_diffrn_radiation_wavelength',G2mth.ValEsd(lam1,slam1))
+                WriteCIFitem(self.fp, '_diffrn_radiation_wavelength',G2mth.ValEsd(lam1,slam1))
 
             if not oneblock:
                 if not phasebyhistDict.get(histlbl):
-                    WriteCIFitem('\n# No phases associated with this data set')
+                    WriteCIFitem(self.fp, '\n# No phases associated with this data set')
                 else:
-                    WriteCIFitem('\n# PHASE TABLE')
-                    WriteCIFitem('loop_' +
-                                 '\n   _pd_phase_id' + 
-                                 '\n   _pd_phase_block_id' + 
+                    WriteCIFitem(self.fp, '\n# PHASE TABLE')
+                    WriteCIFitem(self.fp, 'loop_' +
+                                 '\n   _pd_phase_id' +
+                                 '\n   _pd_phase_block_id' +
                                  '\n   _pd_phase_mass_%')
                     wtFrSum = 0.
@@ -983 +1188 @@
                         else:
                             sig = -0.0001
-                        WriteCIFitem(
+                        WriteCIFitem(self.fp,
                             '  '+
                             str(self.Phases[phasenam]['pId']) +
@@ -989 +1194 @@
                             '  '+G2mth.ValEsd(wtFr,sig)
                             )
-                    WriteCIFitem('loop_' +
+                    WriteCIFitem(self.fp, 'loop_' +
                                  '\n   _gsas_proc_phase_R_F_factor' +
                                  '\n   _gsas_proc_phase_R_Fsqd_factor' +
@@ -996 +1201 @@
                     for phasenam in phasebyhistDict.get(histlbl):
                         pfx = str(self.Phases[phasenam]['pId'])+':'+str(hId)+':'
-                        WriteCIFitem(
+                        WriteCIFitem(self.fp,
                             '  '+
                             '  '+G2mth.ValEsd(histblk[pfx+'Rf']/100.,-.00009) +
@@ -1006 +1211 @@
                 # single phase in this histogram
                 pfx = '0:'+str(hId)+':'
-                WriteCIFitem('_refine_ls_R_F_factor      ','%.5f'%(histblk[pfx+'Rf']/100.))
-                WriteCIFitem('_refine_ls_R_Fsqd_factor   ','%.5f'%(histblk[pfx+'Rf^2']/100.))
-                
-            WriteCIFitem('_pd_proc_ls_prof_R_factor   ','%.5f'%(histblk['R']/100.))
-            WriteCIFitem('_pd_proc_ls_prof_wR_factor  ','%.5f'%(histblk['wR']/100.))
-            WriteCIFitem('_gsas_proc_ls_prof_R_B_factor ','%.5f'%(histblk['Rb']/100.))
-            WriteCIFitem('_gsas_proc_ls_prof_wR_B_factor','%.5f'%(histblk['wRb']/100.))
-            WriteCIFitem('_pd_proc_ls_prof_wR_expected','%.5f'%(histblk['wRmin']/100.))
+                WriteCIFitem(self.fp, '_refine_ls_R_F_factor      ','%.5f'%(histblk[pfx+'Rf']/100.))
+                WriteCIFitem(self.fp, '_refine_ls_R_Fsqd_factor   ','%.5f'%(histblk[pfx+'Rf^2']/100.))
+
+            WriteCIFitem(self.fp, '_pd_proc_ls_prof_R_factor   ','%.5f'%(histblk['R']/100.))
+            WriteCIFitem(self.fp, '_pd_proc_ls_prof_wR_factor  ','%.5f'%(histblk['wR']/100.))
+            WriteCIFitem(self.fp, '_gsas_proc_ls_prof_R_B_factor ','%.5f'%(histblk['Rb']/100.))
+            WriteCIFitem(self.fp, '_gsas_proc_ls_prof_wR_B_factor','%.5f'%(histblk['wRb']/100.))
+            WriteCIFitem(self.fp, '_pd_proc_ls_prof_wR_expected','%.5f'%(histblk['wRmin']/100.))
 
             if histblk['Instrument Parameters'][0]['Type'][1][1] == 'X':
-                WriteCIFitem('_diffrn_radiation_probe','x-ray')
+                WriteCIFitem(self.fp, '_diffrn_radiation_probe','x-ray')
                 pola = histblk['Instrument Parameters'][0].get('Polariz.')
                 if pola:
@@ -1022 +1227 @@
                     sig = self.sigDict.get(pfx+'Polariz.',-0.0009)
                     txt = G2mth.ValEsd(pola[1],sig)
-                    WriteCIFitem('_diffrn_radiation_polarisn_ratio',txt)
+                    WriteCIFitem(self.fp, '_diffrn_radiation_polarisn_ratio',txt)
             elif histblk['Instrument Parameters'][0]['Type'][1][1] == 'N':
-                WriteCIFitem('_diffrn_radiation_probe','neutron')
+                WriteCIFitem(self.fp, '_diffrn_radiation_probe','neutron')
             if 'T' in inst['Type'][0]:
                 txt = G2mth.ValEsd(inst['2-theta'][0],-0.009)
-                WriteCIFitem('_pd_meas_2theta_fixed',txt)
+                WriteCIFitem(self.fp, '_pd_meas_2theta_fixed',txt)
 
             # TODO: this will need help from Bob
             #if not oneblock:
-            #WriteCIFitem('\n# SCATTERING FACTOR INFO')
-            #WriteCIFitem('loop_  _atom_type_symbol')
+            #WriteCIFitem(self.fp, '\n# SCATTERING FACTOR INFO')
+            #WriteCIFitem(self.fp, 'loop_  _atom_type_symbol')
             #if histblk['Instrument Parameters'][0]['Type'][1][1] == 'X':
-            #    WriteCIFitem('      _atom_type_scat_dispersion_real')
-            #    WriteCIFitem('      _atom_type_scat_dispersion_imag')
+            #    WriteCIFitem(self.fp, '      _atom_type_scat_dispersion_real')
+            #    WriteCIFitem(self.fp, '      _atom_type_scat_dispersion_imag')
             #    for lbl in ('a1','a2','a3', 'a4', 'b1', 'b2', 'b3', 'b4', 'c'):
-            #        WriteCIFitem('      _atom_type_scat_Cromer_Mann_'+lbl)
+            #        WriteCIFitem(self.fp, '      _atom_type_scat_Cromer_Mann_'+lbl)
             #elif histblk['Instrument Parameters'][0]['Type'][1][1] == 'N':
-            #    WriteCIFitem('      _atom_type_scat_length_neutron')
-            #WriteCIFitem('      _atom_type_scat_source')
-
-            WriteCIFitem('_pd_proc_ls_background_function',FormatBackground(histblk['Background'],histblk['hId']))
+            #    WriteCIFitem(self.fp, '      _atom_type_scat_length_neutron')
+            #WriteCIFitem(self.fp, '      _atom_type_scat_source')
+
+            WriteCIFitem(self.fp, '_pd_proc_ls_background_function',FormatBackground(histblk['Background'],histblk['hId']))
 
             # TODO: this will need help from Bob
-            #WriteCIFitem('_exptl_absorpt_process_details','?')
-            #WriteCIFitem('_exptl_absorpt_correction_T_min','?')
-            #WriteCIFitem('_exptl_absorpt_correction_T_max','?')
+            #WriteCIFitem(self.fp, '_exptl_absorpt_process_details','?')
+            #WriteCIFitem(self.fp, '_exptl_absorpt_correction_T_min','?')
+            #WriteCIFitem(self.fp, '_exptl_absorpt_correction_T_max','?')
             #C extinction
             #WRITE(IUCIF,'(A)') '# Extinction correction'
@@ -1054 +1259 @@
 
             if not oneblock:                 # instrumental profile terms go here
-                WriteCIFitem('_pd_proc_ls_profile_function', 
+                WriteCIFitem(self.fp, '_pd_proc_ls_profile_function',
                     FormatInstProfile(histblk["Instrument Parameters"],histblk['hId']))
 
@@ -1060 +1265 @@
             refprx = '_refln_' # normal
             # data collection parameters for the powder dataset
-            
+
             temperature = histblk['Sample Parameters'].get('Temperature') # G2 uses K
             if not temperature:
@@ -1066 +1271 @@
             else:
                 T = G2mth.ValEsd(temperature,-0.009,True) # CIF uses K
-            WriteCIFitem('_diffrn_ambient_temperature',T)
+            WriteCIFitem(self.fp, '_diffrn_ambient_temperature',T)
 
             pressure = histblk['Sample Parameters'].get('Pressure') #G2 uses mega-Pascal
@@ -1073 +1278 @@
             else:
                 P = G2mth.ValEsd(pressure*1000,-0.09,True) # CIF uses kilopascal
-            WriteCIFitem('_diffrn_ambient_pressure',P)
-
-            WriteCIFitem('\n# STRUCTURE FACTOR TABLE')            
+            WriteCIFitem(self.fp, '_diffrn_ambient_pressure',P)
+
+            WriteCIFitem(self.fp, '\n# STRUCTURE FACTOR TABLE')
             # compute maximum intensity reflection
             Imax = 0
@@ -1087 +1292 @@
                 Imax = max(Imax,max(I100))
 
-            WriteCIFitem('loop_')
+            WriteCIFitem(self.fp, 'loop_')
             if len(histblk['Reflection Lists'].keys()) > 1:
-                WriteCIFitem('   _pd_refln_phase_id')
-            WriteCIFitem('   ' + refprx + 'index_h' + 
-                         '\n   ' + refprx + 'index_k' + 
-                         '\n   ' + refprx + 'index_l' + 
-                         '\n   ' + refprx + 'F_squared_meas' + 
-                         '\n   ' + refprx + 'F_squared_calc' + 
-                         '\n   ' + refprx + 'phase_calc' + 
+                WriteCIFitem(self.fp, '   _pd_refln_phase_id')
+            WriteCIFitem(self.fp, '   ' + refprx + 'index_h' +
+                         '\n   ' + refprx + 'index_k' +
+                         '\n   ' + refprx + 'index_l' +
+                         '\n   ' + refprx + 'F_squared_meas' +
+                         '\n   ' + refprx + 'F_squared_calc' +
+                         '\n   ' + refprx + 'phase_calc' +
                          '\n   _pd_refln_d_spacing')
             if Imax > 0:
-                WriteCIFitem('   _gsas_i100_meas')
+                WriteCIFitem(self.fp, '   _gsas_i100_meas')
 
             refcount = 0
@@ -1135 +1340 @@
                     if Imax > 0:
                         s += PutInCol(G2mth.ValEsd(100.*I100[j]/Imax,-0.09),6)
-                    WriteCIFitem("  "+s)
+                    WriteCIFitem(self.fp, "  "+s)
 
             WriteReflStat(refcount,hklmin,hklmax,dmin,dmax,len(histblk['Reflection Lists']))
-            WriteCIFitem('\n# POWDER DATA TABLE')
+            WriteCIFitem(self.fp, '\n# POWDER DATA TABLE')
             # is data fixed step? If the step varies by <0.01% treat as fixed step
             steps = histblk['Data'][0][1:] - histblk['Data'][0][:-1]
@@ -1148 +1353 @@
             zero = None
             if fixedstep and 'T' not in inst['Type'][0]: # and not TOF
-                WriteCIFitem('_pd_meas_2theta_range_min', G2mth.ValEsd(histblk['Data'][0][0],-0.00009))
-                WriteCIFitem('_pd_meas_2theta_range_max', G2mth.ValEsd(histblk['Data'][0][-1],-0.00009))
-                WriteCIFitem('_pd_meas_2theta_range_inc', G2mth.ValEsd(steps.sum()/len(steps),-0.00009))
+                WriteCIFitem(self.fp, '_pd_meas_2theta_range_min', G2mth.ValEsd(histblk['Data'][0][0],-0.00009))
+                WriteCIFitem(self.fp, '_pd_meas_2theta_range_max', G2mth.ValEsd(histblk['Data'][0][-1],-0.00009))
+                WriteCIFitem(self.fp, '_pd_meas_2theta_range_inc', G2mth.ValEsd(steps.sum()/len(steps),-0.00009))
                 # zero correct, if defined
                 zerolst = histblk['Instrument Parameters'][0].get('Zero')
@@ -1156 +1361 @@
                 zero = self.parmDict.get('Zero',zero)
                 if zero:
-                    WriteCIFitem('_pd_proc_2theta_range_min', G2mth.ValEsd(histblk['Data'][0][0]-zero,-0.00009))
-                    WriteCIFitem('_pd_proc_2theta_range_max', G2mth.ValEsd(histblk['Data'][0][-1]-zero,-0.00009))
-                    WriteCIFitem('_pd_proc_2theta_range_inc', G2mth.ValEsd(steps.sum()/len(steps),-0.00009))
-                
+                    WriteCIFitem(self.fp, '_pd_proc_2theta_range_min', G2mth.ValEsd(histblk['Data'][0][0]-zero,-0.00009))
+                    WriteCIFitem(self.fp, '_pd_proc_2theta_range_max', G2mth.ValEsd(histblk['Data'][0][-1]-zero,-0.00009))
+                    WriteCIFitem(self.fp, '_pd_proc_2theta_range_inc', G2mth.ValEsd(steps.sum()/len(steps),-0.00009))
+
             if zero:
-                WriteCIFitem('_pd_proc_number_of_points', str(len(histblk['Data'][0])))
+                WriteCIFitem(self.fp, '_pd_proc_number_of_points', str(len(histblk['Data'][0])))
             else:
-                WriteCIFitem('_pd_meas_number_of_points', str(len(histblk['Data'][0])))
-            WriteCIFitem('\nloop_')
-            #            WriteCIFitem('   _pd_proc_d_spacing') # need easy way to get this
+                WriteCIFitem(self.fp, '_pd_meas_number_of_points', str(len(histblk['Data'][0])))
+            WriteCIFitem(self.fp, '\nloop_')
+            #            WriteCIFitem(self.fp, '   _pd_proc_d_spacing') # need easy way to get this
             if not fixedstep:
                 if zero:
-                    WriteCIFitem('   _pd_proc_2theta_corrected')
+                    WriteCIFitem(self.fp, '   _pd_proc_2theta_corrected')
                 elif 'T' in inst['Type'][0]: # and not TOF
-                    WriteCIFitem('   _pd_meas_time_of_flight')
+                    WriteCIFitem(self.fp, '   _pd_meas_time_of_flight')
                 else:
-                    WriteCIFitem('   _pd_meas_2theta_scan')
+                    WriteCIFitem(self.fp, '   _pd_meas_2theta_scan')
             # at least for now, always report weights.
             #if countsdata:
-            #    WriteCIFitem('   _pd_meas_counts_total')
+            #    WriteCIFitem(self.fp, '   _pd_meas_counts_total')
             #else:
-            WriteCIFitem('   _pd_meas_intensity_total')
-            WriteCIFitem('   _pd_calc_intensity_total')
-            WriteCIFitem('   _pd_proc_intensity_bkg_calc')
-            WriteCIFitem('   _pd_proc_ls_weight')
+            WriteCIFitem(self.fp, '   _pd_meas_intensity_total')
+            WriteCIFitem(self.fp, '   _pd_calc_intensity_total')
+            WriteCIFitem(self.fp, '   _pd_proc_intensity_bkg_calc')
+            WriteCIFitem(self.fp, '   _pd_proc_ls_weight')
             maxY = max(histblk['Data'][1].max(),histblk['Data'][3].max())
             if maxY < 0: maxY *= -10 # this should never happen, but...
@@ -1191 +1396 @@
             if DEBUG:
                 print('DEBUG: skipping profile list')
-            else:    
+            else:
                 for x,yobs,yw,ycalc,ybkg in zip(histblk['Data'][0],
                                                 histblk['Data'][1],
@@ -1201 +1406 @@
                     else:
                         yw = 0.0 # show the point is not in use
-    
+
                     if fixedstep:
                         s = ""
@@ -1212 +1417 @@
                     s += PutInCol(Yfmt(ndec,ybkg),11)
                     s += PutInCol(Yfmt(ndecSU,yw),9)
-                    WriteCIFitem("  "+s)
+                    WriteCIFitem(self.fp, "  "+s)
 
         def WriteSingleXtalData(histlbl):
@@ -1221 +1426 @@
             refprx = '_refln_' # normal
 
-            WriteCIFitem('\n# STRUCTURE FACTOR TABLE')            
-            WriteCIFitem('loop_' + 
-                         '\n   ' + refprx + 'index_h' + 
-                         '\n   ' + refprx + 'index_k' + 
+            WriteCIFitem(self.fp, '\n# STRUCTURE FACTOR TABLE')
+            WriteCIFitem(self.fp, 'loop_' +
+                         '\n   ' + refprx + 'index_h' +
+                         '\n   ' + refprx + 'index_k' +
                          '\n   ' + refprx + 'index_l' +
-                         '\n   ' + refprx + 'F_squared_meas' + 
-                         '\n   ' + refprx + 'F_squared_sigma' + 
-                         '\n   ' + refprx + 'F_squared_calc' + 
+                         '\n   ' + refprx + 'F_squared_meas' +
+                         '\n   ' + refprx + 'F_squared_sigma' +
+                         '\n   ' + refprx + 'F_squared_calc' +
                          '\n   ' + refprx + 'phase_calc'
                          )
@@ -1262 +1467 @@
                 dmax = max(dmax,ref[4])
                 dmin = min(dmin,ref[4])
-                WriteCIFitem(s)
+                WriteCIFitem(self.fp, s)
             if not self.quickmode: # statistics only in a full CIF
                 WriteReflStat(refcount,hklmin,hklmax,dmin,dmax)
@@ -1270 +1475 @@
                 extType,extModel,extParms = self.Phases[phasenam]['Histograms'][histlbl]['Extinction']
                 if extModel != 'None':
-                    WriteCIFitem('# Extinction scaled by 1.e5')
-                    WriteCIFitem('_refine_ls_extinction_method','Becker-Coppens %s %s'%(extModel,extType))
+                    WriteCIFitem(self.fp, '# Extinction scaled by 1.e5')
+                    WriteCIFitem(self.fp, '_refine_ls_extinction_method','Becker-Coppens %s %s'%(extModel,extType))
                     sig = -1.e-3
                     if extModel == 'Primary':
@@ -1298 +1503 @@
                             sig = self.sigDict[phfx+'Es']*1.e5
                         text += G2mth.ValEsd(parm,sig)
-                    WriteCIFitem('_refine_ls_extinction_coef',text)
-                    WriteCIFitem('_refine_ls_extinction_expression','Becker & Coppens (1974). Acta Cryst. A30, 129-147')
-
-                WriteCIFitem('_refine_ls_wR_factor_gt    ','%.4f'%(histblk['wR']/100.))
-                WriteCIFitem('_refine_ls_R_factor_gt     ','%.4f'%(histblk[hfx+'Rf']/100.))
-                WriteCIFitem('_refine_ls_R_Fsqd_factor   ','%.4f'%(histblk[hfx+'Rf^2']/100.))
+                    WriteCIFitem(self.fp, '_refine_ls_extinction_coef',text)
+                    WriteCIFitem(self.fp, '_refine_ls_extinction_expression','Becker & Coppens (1974). Acta Cryst. A30, 129-147')
+
+                WriteCIFitem(self.fp, '_refine_ls_wR_factor_gt    ','%.4f'%(histblk['wR']/100.))
+                WriteCIFitem(self.fp, '_refine_ls_R_factor_gt     ','%.4f'%(histblk[hfx+'Rf']/100.))
+                WriteCIFitem(self.fp, '_refine_ls_R_Fsqd_factor   ','%.4f'%(histblk[hfx+'Rf^2']/100.))
         def EditAuthor(event=None):
             'dialog to edit the CIF author info'
@@ -1329 +1534 @@
             lbllist = []
             for hist in self.Histograms:
-                if hist.startswith("PWDR"): 
+                if hist.startswith("PWDR"):
                     key2 = "Sample Parameters"
                     d = self.Histograms[hist][key2]
-                elif hist.startswith("HKLF"): 
+                elif hist.startswith("HKLF"):
                     key2 = "Instrument Parameters"
                     d = self.Histograms[hist][key2][0]
-                    
+
                 lbllist.append(hist)
                 dictlist.append(d)
@@ -1349 +1554 @@
                 header="Edit instrument names. Note that a non-blank\nname is required for all histograms",
                 CopyButton=True,ASCIIonly=True)
-            
+
         def EditRanges(event):
             '''Edit the bond distance/angle search range; phase is determined from
@@ -1359 +1564 @@
             dlg = G2G.DisAglDialog(
                 self.G2frame,
-                phasedict['General']['DisAglCtls'], # edited 
+                phasedict['General']['DisAglCtls'], # edited
                 phasedict['General'], # defaults
                 )
@@ -1365 +1570 @@
                 phasedict['General']['DisAglCtls'] = dlg.GetData()
             dlg.Destroy()
-            
+
         def EditCIFDefaults():
             '''Fills the CIF Defaults window with controls for editing various CIF export
@@ -1382 +1587 @@
             cpnl = wxscroll.ScrolledPanel(self.cifdefs,size=(300,300))
             cbox = wx.BoxSizer(wx.VERTICAL)
-            G2G.HorizontalLine(cbox,cpnl)          
+            G2G.HorizontalLine(cbox,cpnl)
             cbox.Add(
                 CIFtemplateSelect(self.cifdefs,
@@ -1391 +1596 @@
                 0,wx.EXPAND|wx.ALIGN_LEFT|wx.ALL)
             for phasenam in sorted(self.Phases.keys()):
-                G2G.HorizontalLine(cbox,cpnl)          
+                G2G.HorizontalLine(cbox,cpnl)
                 title = 'Phase '+phasenam
-                phasedict = self.Phases[phasenam] # pointer to current phase info            
+                phasedict = self.Phases[phasenam] # pointer to current phase info
                 cbox.Add(
                     CIFtemplateSelect(self.cifdefs,
@@ -1402 +1607 @@
                     0,wx.EXPAND|wx.ALIGN_LEFT|wx.ALL)
                 cpnl.SetSizer(cbox)
-                if phasedict['General']['Type'] == 'nuclear':  
+                if phasedict['General']['Type'] == 'nuclear':
                     but = wx.Button(cpnl, wx.ID_ANY,'Edit distance/angle ranges')
                     cbox.Add(but,0,wx.ALIGN_LEFT,0)
@@ -1409 +1614 @@
                     but.Bind(wx.EVT_BUTTON,EditRanges)     # phase bond/angle ranges
                     but = wx.Button(cpnl, wx.ID_ANY,'Set distance/angle publication flags')
-                    but.phase = phasenam  # set a pointer to current phase info     
+                    but.phase = phasenam  # set a pointer to current phase info
                     but.Bind(wx.EVT_BUTTON,SelectDisAglFlags)     # phase bond/angle ranges
                     cbox.Add(but,0,wx.ALIGN_LEFT,0)
                 cbox.Add((-1,2))
             for i in sorted(self.powderDict.keys()):
-                G2G.HorizontalLine(cbox,cpnl)          
+                G2G.HorizontalLine(cbox,cpnl)
                 hist = self.powderDict[i]
                 histblk = self.Histograms[hist]
@@ -1426 +1631 @@
                     0,wx.EXPAND|wx.ALIGN_LEFT|wx.ALL)
             for i in sorted(self.xtalDict.keys()):
-                G2G.HorizontalLine(cbox,cpnl)          
+                G2G.HorizontalLine(cbox,cpnl)
                 hist = self.xtalDict[i]
                 histblk = self.Histograms[hist]
@@ -1455 +1660 @@
             vbox.Fit(self.cifdefs)
             self.cifdefs.Layout()
-            
+
         def OnToggleButton(event):
             'Respond to press of ToggleButton in SelectDisAglFlags'
             but = event.GetEventObject()
-            if but.GetValue():                    
+            if but.GetValue():
                 but.DisAglSel[but.key] = True
             else:
@@ -1470 +1675 @@
         def keepFalse(event):
             event.GetEventObject().SetValue(False)
-                
+
         def SelectDisAglFlags(event):
             'Select Distance/Angle use flags for the selected phase'
@@ -1488 +1693 @@
             # create a list of atoms, but skip atoms with zero occupancy
             xyz = []
-            fpfx = str(phasedict['pId'])+'::Afrac:'        
+            fpfx = str(phasedict['pId'])+'::Afrac:'
             for i,atom in enumerate(phasedict['Atoms']):
                 if self.parmDict.get(fpfx+str(i),atom[cfrac]) == 0.0: continue
@@ -1542 +1747 @@
             wx.EndBusyCursor()
             txt.SetLabel('Set publication flags for distances and angles in\nphase '+phasenam)
-            vbox.Add((5,5)) 
+            vbox.Add((5,5))
             vbox.Add(wx.StaticText(dlg,wx.ID_ANY,
                                    'The default is to flag all distances and angles as to be'+
@@ -1557 +1762 @@
             hbox.Add(but)
             but.SetValue(True)
-            G2G.HorizontalLine(vbox,dlg)          
-            
+            G2G.HorizontalLine(vbox,dlg)
+
             cpnl = wxscroll.ScrolledPanel(dlg,size=(400,300))
             cbox = wx.BoxSizer(wx.VERTICAL)
@@ -1574 +1779 @@
                     dbox.Add(wx.StaticText(cpnl,wx.ID_ANY,AtomLabels[D[0]]),
                              (i+1,0)
-                             )                    
+                             )
                     dbox.Add(wx.StaticText(cpnl,wx.ID_ANY,sym),
                              (i+1,1)
@@ -1604 +1809 @@
                                  )
                 cbox.Add(dbox)
-                G2G.HorizontalLine(cbox,cpnl)          
+                G2G.HorizontalLine(cbox,cpnl)
             cpnl.SetSizer(cbox)
             cpnl.SetAutoLayout(1)
@@ -1622 +1827 @@
             vbox.Fit(dlg)
             dlg.Layout()
-            
+
             dlg.CenterOnParent()
             dlg.ShowModal()
-            
+
 #=================================================================================
 #===== end of function definitions for _Exporter =================================
@@ -1631 +1836 @@
         # make sure required information is present
         self.CIFdate = dt.datetime.strftime(dt.datetime.now(),"%Y-%m-%dT%H:%M")
-        if not self.CIFname: # Get a name for the CIF. If not defined, use the GPX name (save, if that is needed). 
+        if not self.CIFname: # Get a name for the CIF. If not defined, use the GPX name (save, if that is needed).
             if not self.G2frame.GSASprojectfile:
                 self.G2frame.OnFileSaveas(None)
@@ -1653 +1858 @@
             pass
         #=================================================================
-        # write quick CIFs 
+        # write quick CIFs
         #=================================================================
         if phaseOnly: #====Phase only CIF ================================
@@ -1662 +1867 @@
             self.Write(' ')
             self.Write(70*'#')
-            WriteCIFitem('data_'+self.CIFname)
+            WriteCIFitem(self.fp, 'data_'+self.CIFname)
             #phaseblk = self.Phases[phaseOnly] # pointer to current phase info
             # report the phase info
@@ -1680 +1885 @@
             self.Write(70*'#')
             #phasenam = self.Phases.keys()[0]
-            WriteCIFitem('data_'+self.CIFname)
+            WriteCIFitem(self.fp, 'data_'+self.CIFname)
             #print 'phasenam',phasenam
             #phaseblk = self.Phases[phasenam] # pointer to current phase info
             #instnam = instnam.replace(' ','')
-            #WriteCIFitem('_pd_block_id',
+            #WriteCIFitem(self.fp, '_pd_block_id',
             #             str(self.CIFdate) + "|" + str(self.CIFname) + "|" +
             #             str(self.shortauthorname) + "|" + instnam + '|' + histname)
@@ -1697 +1902 @@
             #MD = FormatHAPpo(phasenam)
             #if SH and MD:
-            #    WriteCIFitem('_pd_proc_ls_pref_orient_corr', SH + '\n' + MD)
+            #    WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + '\n' + MD)
             #elif SH or MD:
-            #    WriteCIFitem('_pd_proc_ls_pref_orient_corr', SH + MD)
+            #    WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + MD)
             #else:
-            #    WriteCIFitem('_pd_proc_ls_pref_orient_corr', 'none')
+            #    WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', 'none')
             # report profile, since one-block: include both histogram and phase info
-            #WriteCIFitem('_pd_proc_ls_profile_function',
+            #WriteCIFitem(self.fp, '_pd_proc_ls_profile_function',
             #    FormatInstProfile(histblk["Instrument Parameters"],histblk['hId'])
             #        +'\n'+FormatPhaseProfile(phasenam))
@@ -1713 +1918 @@
         #elif IncludeOnlyHist is not None: # truncate histogram list to only selected (for sequential export)
         #    self.Histograms = {IncludeOnlyHist:self.Histograms[IncludeOnlyHist]}
-        
+
         #===============================================================================
         # the export process for a full CIF starts here
@@ -1764 +1969 @@
                 self.ifHKLF = True
                 key2 = "Instrument Parameters"
-                d = self.Histograms[hist][key2][0]                    
+                d = self.Histograms[hist][key2][0]
             instrname = d.get(key3)
             if instrname is None:
@@ -1779 +1984 @@
             #    )
             if not EditInstNames(): return
-            
+
         # check for a distance-angle range search range for each phase
         for phasenam in sorted(self.Phases.keys()):
             #i = self.Phases[phasenam]['pId']
-            phasedict = self.Phases[phasenam] # pointer to current phase info            
+            phasedict = self.Phases[phasenam] # pointer to current phase info
             if 'DisAglCtls' not in phasedict['General']:
                 dlg = G2G.DisAglDialog(
@@ -1799 +2004 @@
         default = 0
         for hist in self.Histograms:
-            if hist.startswith("PWDR"): 
+            if hist.startswith("PWDR"):
                 key2 = "Sample Parameters"
                 T = self.Histograms[hist][key2].get('Temperature')
@@ -1825 +2030 @@
             for hist in self.Histograms:
                 histblk = self.Histograms[hist]
-                if hist.startswith("PWDR"): 
+                if hist.startswith("PWDR"):
                     instnam = histblk["Sample Parameters"]['InstrName']
                     break # ignore all but 1st data histogram
-                elif hist.startswith("HKLF"): 
+                elif hist.startswith("HKLF"):
                     instnam = histblk["Instrument Parameters"][0]['InstrName']
                     break # ignore all but 1st data histogram
@@ -1858 +2063 @@
             hist = self.histnam[0]
             self.CIFname = hist[5:40].replace(' ','')
-            WriteCIFitem('data_'+self.CIFname)
+            WriteCIFitem(self.fp, 'data_'+self.CIFname)
             if hist.startswith("PWDR"):
                 WritePowderData(hist)
@@ -1867 +2072 @@
         elif oneblock:
             #====Single block, data & phase CIF ===================================
-            WriteCIFitem('data_'+self.CIFname)
-            if phasenam is None: # if not already selected, select the first phase (should be one) 
+            WriteCIFitem(self.fp, 'data_'+self.CIFname)
+            if phasenam is None: # if not already selected, select the first phase (should be one)
                 phasenam = self.Phases.keys()[0]
             #print 'phasenam',phasenam
             #phaseblk = self.Phases[phasenam] # pointer to current phase info
             instnam = instnam.replace(' ','')
-            WriteCIFitem('_pd_block_id',
+            WriteCIFitem(self.fp, '_pd_block_id',
                          str(self.CIFdate) + "|" + str(self.CIFname) + "|" +
                          str(self.shortauthorname) + "|" + instnam)
@@ -1887 +2092 @@
                 MD = FormatHAPpo(phasenam)
                 if SH and MD:
-                    WriteCIFitem('_pd_proc_ls_pref_orient_corr', SH + '\n' + MD)
+                    WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + '\n' + MD)
                 elif SH or MD:
-                    WriteCIFitem('_pd_proc_ls_pref_orient_corr', SH + MD)
+                    WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + MD)
                 else:
-                    WriteCIFitem('_pd_proc_ls_pref_orient_corr', 'none')
+                    WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', 'none')
                     # report profile, since one-block: include both histogram and phase info
-                WriteCIFitem('_pd_proc_ls_profile_function',
+                WriteCIFitem(self.fp, '_pd_proc_ls_profile_function',
                     FormatInstProfile(histblk["Instrument Parameters"],histblk['hId'])
                     +'\n'+FormatPhaseProfile(phasenam))
@@ -1915 +2120 @@
             step = 1
             dlg.Update(step,"Exporting overall section")
-            WriteCIFitem('\ndata_'+self.CIFname+'_publ')
+            WriteCIFitem(self.fp, '\ndata_'+self.CIFname+'_publ')
             WriteAudit()
-            WriteCIFitem('_pd_block_id',
+            WriteCIFitem(self.fp, '_pd_block_id',
                          str(self.CIFdate) + "|" + str(self.CIFname) + "|" +
                          str(self.shortauthorname) + "|Overall")
@@ -1923 +2128 @@
             # ``template_publ.cif`` or a modified version
             # overall info
-            WriteCIFitem('data_'+str(self.CIFname)+'_overall')
+            WriteCIFitem(self.fp, 'data_'+str(self.CIFname)+'_overall')
             WriteOverall()
             #============================================================
-            WriteCIFitem('# POINTERS TO PHASE AND HISTOGRAM BLOCKS')
+            WriteCIFitem(self.fp, '# POINTERS TO PHASE AND HISTOGRAM BLOCKS')
             datablockidDict = {} # save block names here -- N.B. check for conflicts between phase & hist names (unlikely!)
             # loop over phase blocks
             if len(self.Phases) > 1:
                 loopprefix = ''
-                WriteCIFitem('loop_   _pd_phase_block_id')
+                WriteCIFitem(self.fp, 'loop_   _pd_phase_block_id')
             else:
                 loopprefix = '_pd_phase_block_id'
@@ -1939 +2144 @@
                 datablockidDict[phasenam] = (str(self.CIFdate) + "|" + str(self.CIFname) + "|" +
                              'phase_'+ str(i) + '|' + str(self.shortauthorname))
-                WriteCIFitem(loopprefix,datablockidDict[phasenam])
+                WriteCIFitem(self.fp, loopprefix,datablockidDict[phasenam])
             # loop over data blocks
             if len(self.powderDict) + len(self.xtalDict) > 1:
                 loopprefix = ''
-                WriteCIFitem('loop_   _pd_block_diffractogram_id')
+                WriteCIFitem(self.fp, 'loop_   _pd_block_diffractogram_id')
             else:
                 loopprefix = '_pd_block_diffractogram_id'
@@ -1955 +2160 @@
                                          str(self.shortauthorname) + "|" +
                                          instnam + "_hist_"+str(j))
-                WriteCIFitem(loopprefix,datablockidDict[hist])
+                WriteCIFitem(self.fp, loopprefix,datablockidDict[hist])
             for i in sorted(self.xtalDict.keys()):
                 hist = self.xtalDict[i]
@@ -1965 +2170 @@
                                          str(self.shortauthorname) + "|" +
                                          instnam + "_hist_"+str(i))
-                WriteCIFitem(loopprefix,datablockidDict[hist])
+                WriteCIFitem(self.fp, loopprefix,datablockidDict[hist])
             #============================================================
             # loop over phases, exporting them
@@ -1973 +2178 @@
                 dlg.Update(step,"Exporting phase "+phasenam+' (#'+str(j+1)+')')
                 i = self.Phases[phasenam]['pId']
-                WriteCIFitem('\ndata_'+self.CIFname+"_phase_"+str(i))
-                WriteCIFitem('# Information for phase '+str(i))
-                WriteCIFitem('_pd_block_id',datablockidDict[phasenam])
+                WriteCIFitem(self.fp, '\ndata_'+self.CIFname+"_phase_"+str(i))
+                WriteCIFitem(self.fp, '# Information for phase '+str(i))
+                WriteCIFitem(self.fp, '_pd_block_id',datablockidDict[phasenam])
                 # report the phase
                 writeCIFtemplate(self.Phases[phasenam]['General'],'phase',phasenam) # write phase template
@@ -1984 +2189 @@
                     MD = FormatHAPpo(phasenam)
                     if SH and MD:
-                        WriteCIFitem('_pd_proc_ls_pref_orient_corr', SH + '\n' + MD)
+                        WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + '\n' + MD)
                     elif SH or MD:
-                        WriteCIFitem('_pd_proc_ls_pref_orient_corr', SH + MD)
+                        WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', SH + MD)
                     else:
-                        WriteCIFitem('_pd_proc_ls_pref_orient_corr', 'none')
+                        WriteCIFitem(self.fp, '_pd_proc_ls_pref_orient_corr', 'none')
                 # report sample profile terms
                 PP = FormatPhaseProfile(phasenam)
                 if PP:
-                    WriteCIFitem('_pd_proc_ls_profile_function',PP)
+                    WriteCIFitem(self.fp, '_pd_proc_ls_profile_function',PP)
 
             #============================================================
@@ -1999 +2204 @@
                 hist = self.powderDict[i]
                 histblk = self.Histograms[hist]
-                if hist.startswith("PWDR"): 
+                if hist.startswith("PWDR"):
                     step += 1
                     dlg.Update(step,"Exporting "+hist.strip())
-                    WriteCIFitem('\ndata_'+self.CIFname+"_pwd_"+str(i))
+                    WriteCIFitem(self.fp, '\ndata_'+self.CIFname+"_pwd_"+str(i))
                     #instnam = histblk["Sample Parameters"]['InstrName']
                     # report instrumental profile terms
-                    WriteCIFitem('_pd_proc_ls_profile_function',
+                    WriteCIFitem(self.fp, '_pd_proc_ls_profile_function',
                         FormatInstProfile(histblk["Instrument Parameters"],histblk['hId']))
-                    WriteCIFitem('# Information for histogram '+str(i)+': '+hist)
-                    WriteCIFitem('_pd_block_id',datablockidDict[hist])
+                    WriteCIFitem(self.fp, '# Information for histogram '+str(i)+': '+hist)
+                    WriteCIFitem(self.fp, '_pd_block_id',datablockidDict[hist])
                     histprm = self.Histograms[hist]["Sample Parameters"]
                     writeCIFtemplate(histprm,'powder',histprm['InstrName']) # powder template
@@ -2015 +2220 @@
                 hist = self.xtalDict[i]
                 histblk = self.Histograms[hist]
-                if hist.startswith("HKLF"): 
+                if hist.startswith("HKLF"):
                     step += 1
                     dlg.Update(step,"Exporting "+hist.strip())
-                    WriteCIFitem('\ndata_'+self.CIFname+"_sx_"+str(i))
+                    WriteCIFitem(self.fp, '\ndata_'+self.CIFname+"_sx_"+str(i))
                     #instnam = histblk["Instrument Parameters"][0]['InstrName']
-                    WriteCIFitem('# Information for histogram '+str(i)+': '+hist)
-                    WriteCIFitem('_pd_block_id',datablockidDict[hist])
+                    WriteCIFitem(self.fp, '# Information for histogram '+str(i)+': '+hist)
+                    WriteCIFitem(self.fp, '_pd_block_id',datablockidDict[hist])
                     histprm = self.Histograms[hist]["Instrument Parameters"][0]
                     writeCIFtemplate(histprm,'single',histprm['InstrName']) # single crystal template
@@ -2028 +2233 @@
             dlg.Destroy()
 
-        WriteCIFitem('#--' + 15*'eof--' + '#')
+        WriteCIFitem(self.fp, '#--' + 15*'eof--' + '#')
         #self.CloseFile()
         print("...export completed")
@@ -2047 +2252 @@
             )
         self.exporttype = ['project']
-        
+
     def Exporter(self,event=None):
         self._Exporter(event=event)
@@ -2066 +2271 @@
     #         print('CIF written to file '+self.fullpath)
     #     self.CloseFile()
-        
+
 class ExportPhaseCIF(ExportCIF):
     '''Used to create a simple CIF with one phase. Uses exact same code as
@@ -2155 +2360 @@
             print('CIF written to file '+self.fullpath)
         self.CloseFile()
-        
+
 class ExportHKLCIF(ExportCIF):
     '''Used to create a simple CIF containing diffraction data only. Uses exact same code as
@@ -2187 +2392 @@
             ): return
         self._Exporter(event=event,histOnly=self.histnam[0])
-                
+
 #===============================================================================
 # misc CIF utilities
@@ -2200 +2405 @@
     :param str fil: file name of CIF dictionary, will usually end
       in .dic
-    :returns: the dict with the definitions  
+    :returns: the dict with the definitions
     '''
     import CifFile as cif # PyCifRW from James Hester
@@ -2238 +2443 @@
     cif_core.dic and/or cif_pd.dic are read.
 
-    :returns: the dict with the definitions  
+    :returns: the dict with the definitions
     '''
     cifdic = {}
@@ -2301 +2506 @@
     :returns: cifblk, loopstructure where cifblk is a dict with
       CIF items and loopstructure is a list of lists that defines
-      which items are in which loops. 
+      which items are in which loops.
     '''
     blk = cf.keys()[0] # assume templates are a single CIF block, use the 1st
@@ -2332 +2537 @@
       Defaults to 'Template'
 
-    :returns: the newly created PyCifRW CIF object 
+    :returns: the newly created PyCifRW CIF object
     '''
 
@@ -2354 +2559 @@
     # create a CIF and add the block
     newcf = cif.CifFile()
-    newcf[blockname] = newblk    
+    newcf[blockname] = newblk
     return newcf
 
@@ -2362 +2567 @@
     placed in cifblk. If the CIF is saved as a file, the name of that file
     is saved as ``self.newfile``.
-    
+
     :param wx.Frame parent: parent frame or None
     :param cifblk: dict or PyCifRW block containing values for each CIF item
@@ -2378 +2583 @@
       Note that the values for each looped CIF item, such as _a,
       are contained in a list, for example as cifblk["_a"]
-      
-    :param str defaultname: specifies the default file name to be used for 
+
+    :param str defaultname: specifies the default file name to be used for
       saving the CIF.
     '''
@@ -2387 +2592 @@
         self.loopstructure = loopstructure
         self.newfile = None
-        self.defaultname = defaultname        
+        self.defaultname = defaultname
         global CIFdic  # once this is loaded, keep it around
         if CIFdic is None:
@@ -2419 +2624 @@
     def Post(self):
         '''Display the dialog
-        
+
         :returns: True unless Cancel has been pressed.
         '''
@@ -2504 +2709 @@
             but = wx.Button(self,wx.ID_ANY,"Add row")
             self.AddDict[but]=lnum
-            
-            hbox.Add(but)            
+
+            hbox.Add(but)
             but.Bind(wx.EVT_BUTTON,self.OnAddRow)
             fbox = wx.GridBagSizer(0, 0)
@@ -2541 +2746 @@
             line = wx.StaticLine(self,wx.ID_ANY, size=(-1,3), style=wx.LI_HORIZONTAL)
             vbox.Add(line, 0, wx.EXPAND|wx.ALIGN_CENTER|wx.ALL, 10)
-                
+
         # post the non-looped CIF items
         for item in sorted(self.cifblk.keys()):
@@ -2571 +2776 @@
         self.DoLayout after the current operations are complete using
         CallAfter. This is called only once, according to flag
-        self.LayoutCalled, which is cleared in self.DoLayout. 
+        self.LayoutCalled, which is cleared in self.DoLayout.
         '''
         if self.LayoutCalled: return # call already queued
@@ -2616 +2821 @@
             for btn in self.parentOKbuttons:
                 btn.Disable()
-        
+
     def CIFEntryWidget(self,dct,item,dataname):
         '''Create an entry widget for a CIF item. Use a validated entry for numb values
@@ -2622 +2827 @@
         At present this does not allow entry of the special CIF values of "." and "?" for
         numerical values and highlights them as invalid.
-        Use a selection widget when there are specific enumerated values for a string.        
+        Use a selection widget when there are specific enumerated values for a string.
         '''
         if self.cifdic.get(dataname):
@@ -2658 +2863 @@
 class CIFtemplateSelect(wx.BoxSizer):
     '''Create a set of buttons to show, select and edit a CIF template
-    
+
     :param frame: wx.Frame object of parent
     :param panel: wx.Panel object where widgets should be placed
@@ -2666 +2871 @@
       "CIF_template" will be used to store either a list or a string.
       If a list, it will contain a dict and a list defining loops. If
-      an str, it will contain a file name.    
+      an str, it will contain a file name.
     :param function repaint: reference to a routine to be called to repaint
       the frame after a change has been made
     :param str title: A line of text to show at the top of the window
-    :param str defaultname: specifies the default file name to be used for 
+    :param str defaultname: specifies the default file name to be used for
       saving the CIF.
     '''
@@ -2686 +2891 @@
         else:
             self.defaultname = ''
-            
+
         txt = wx.StaticText(panel,wx.ID_ANY,title)
         self.Add(txt,0,wx.ALIGN_CENTER)
@@ -2776 +2981 @@
             self.repaint() #EditCIFDefaults() # note that this does a dlg.Destroy()
         else:
-            dlg.Destroy()        
+            dlg.Destroy()
 
 #===============================================================================