source: trunk/addcmds.tcl @ 354

# $Id: addcmds.tcl 354 2009-12-04 23:04:43Z toby $

proc MakeAddPhaseBox {} {
    global expmap expgui tcl_platform

    set expgui(coordList) {}
    set nextphase ""
    foreach p {1 2 3 4 5 6 7 8 9} {
        if {[lsearch $expmap(phaselist) $p] == -1} {
            set nextphase $p
            break
        }
    }

    # no more room
    if {$nextphase == ""} {
        tk_dialog .phaseerr "Add Phase Error" \
                "There are already 9 phases. You cannot add more." \
                error 0 "OK" 
        return
    }

    set np .newphase
    catch {destroy $np}
    toplevel $np
    bind $np <Key-F1> "MakeWWWHelp expgui2.html addphase"

    grid [label $np.l1 -text "Adding phase #$nextphase"] \
            -column 0 -row 0 -sticky w
    grid [label $np.l2 -text "Phase title:"] -column 0 -row 1 
    grid [entry $np.t1 -width 68] -column 1 -row 1 -columnspan 8
    grid [label $np.l3 -text "Space Group:"] -column 0 -row 2 
    grid [entry $np.t2 -width 12] -column 1 -row 2 
    grid [frame $np.f -bd 4 -relief groove] -column 3 -row 2 -columnspan 8
    set col -1
    foreach i {a b c} {
        grid [label $np.f.l1$i -text " $i "] -column [incr col] -row 1
        grid [entry $np.f.e1$i -width 12] -column [incr col]  -row 1
    }
    set col -1
    foreach i {a b g} {
        grid [label $np.f.l2$i -text $i -font symbol] -column [incr col] -row 2
        grid [entry $np.f.e2$i -width 12] -column [incr col]  -row 2
        $np.f.e2$i insert 0 90.
    }   
    
    grid [frame $np.bf] -row 3 -column 0 -columnspan 10 -sticky ew
    grid [button $np.bf.b1 -text Add \
            -command "addphase $np"] -column 2 -row 3
    bind $np <Return> "addphase $np"
    grid [button $np.bf.b2 -text Cancel \
            -command "destroy $np"] -column 3 -row 3
    grid columnconfig $np.bf 4 -weight 1
    grid [button $np.bf.help -text Help -bg yellow \
            -command "MakeWWWHelp expgui2.html addphase"] \
            -column 4 -row 3

    # get the input formats if not already defined
    GetImportFormats
    if {[llength $expgui(importFormatList)] > 0} {
        grid [frame $np.bf.fr -bd 4 -relief groove] -column 5 -row 3
        grid [button $np.bf.fr.b3 -text "Import phase from: " \
                -command "ImportPhase \$expgui(importFormat) $np"] \
                -column 0 -row 0 -sticky e
        eval tk_optionMenu $np.bf.fr.b4 expgui(importFormat) \
                $expgui(importFormatList)
        grid $np.bf.fr.b4 -column 1 -row 0 -sticky w
        grid rowconfig $np.bf.fr 0 -pad 10
        grid columnconfig $np.bf.fr 0 -pad 10
        grid columnconfig $np.bf.fr 1 -pad 10
    }
    wm title $np "add new phase"

    # set grab, etc.
    putontop $np
    
    tkwait window $np
    
    # fix grab...
    afterputontop
}

proc addphase {np} {
    global expgui expmap
    # validate the input
    set err {}
    set title [$np.t1 get]
    if {[string trim $title] == ""} {
        append err "  Title cannot be blank\n"
    }
    set spg [$np.t2 get]
    if {[string trim $spg] == ""} {
        append err "  Space group cannot be blank\n"
    }
    foreach i {a b c} {
        set cell($i) [$np.f.e1$i get]
        if {[string trim $cell($i)] == ""} {
            append err "  $i cannot be blank\n"
        } elseif {[catch {expr $cell($i)}]} {
            append err "  $i is not valid\n"
        }
    }

    foreach i {a b g} lbl {alpha beta gamma} {
        set cell($lbl) [$np.f.e2$i get]
        if {[string trim $cell($lbl)] == ""} {
            append err "  $lbl cannot be blank\n"
        } elseif {[catch {expr $cell($lbl)}]} {
            append err "  $lbl is not valid\n"
        }
    }

    if {$err != ""} {
        tk_dialog .phaseerr "Add Phase Error" \
                "The following error(s) were found in your input:\n$err" \
                error 0 "OK" 
        return
    }

    # check the space group
    set fp [open spg.in w]
    puts $fp "N"
    puts $fp "N"
    puts $fp $spg
    puts $fp "Q"
    close $fp
    global tcl_platform
    catch {
        if {$tcl_platform(platform) == "windows"} {
            exec [file join $expgui(gsasexe) spcgroup.exe] < spg.in >& spg.out
        } else {
            exec [file join $expgui(gsasexe) spcgroup] < spg.in >& spg.out
        }
    }
    set fp [open spg.out r]
    set out [read $fp]
    close $fp
    # attempt to parse out the output (fix up if parse did not work)
    if {[regexp "space group symbol.*>(.*)Enter a new space group symbol" \
            $out a b ] != 1} {set b $out}
    if {[string first Error $b] != -1} {
        # got an error, show it
        ShowBigMessage \
                 $np.error \
                 "Error processing space group\nReview error message below" \
                 $b
        return
    } else {
        # show the result and confirm
        set opt [ShowBigMessage \
                $np.check \
                "Check the symmetry operators in the output below" \
                $b \
                {Continue Redo} ]
        if {$opt > 1} return
    }
    file delete spg.in spg.out
    
    # ok do it!
    set fp [open exptool.in w]
    puts $fp "P"
    puts $fp $title
    puts $fp $spg
    puts $fp "$cell(a) $cell(b) $cell(c) $cell(alpha) $cell(beta) $cell(gamma)"
    puts $fp "/"
    close $fp
    global tcl_platform
    # Save the current exp file
    savearchiveexp
    # disable the file changed monitor
    set expgui(expModifiedLast) 0
    set expnam [file root [file tail $expgui(expfile)]]
    # save the previous phase list
    set expgui(oldphaselist) $expmap(phaselist)
    catch {
        if {$tcl_platform(platform) == "windows"} {
            exec [file join $expgui(gsasexe) exptool.exe] $expnam \
                    < exptool.in >& exptool.out
        } else {
            exec [file join $expgui(gsasexe) exptool] $expnam \
                    < exptool.in >& exptool.out
        }
    } errmsg
    # load the revised exp file
    loadexp $expgui(expfile)
    set fp [open exptool.out r]
    set out [read $fp]
    close $fp
    destroy $np
    if {$errmsg != ""} {
        append errmsg "\n" $out
    } else {
        set errmsg $out
    }
    if {$expgui(showexptool)} {
        ShowBigMessage \
                $np \
                "Please review the result from adding the phase" \
                $errmsg
    }
    file delete exptool.in exptool.out
    # now select the new phase
    SelectOnePhase [lindex $expmap(phaselist) end]    
}

proc MakeAddHistBox {} {
    global expmap newhist

    # --> should check here if room for another histogram, but only texture
    # folks will ever need that

    set np .newhist
    catch {destroy $np}
    toplevel $np
    bind $np <Key-F1> "MakeWWWHelp expgui3.html AddHist"

    grid [label $np.l0 -text "Adding new histogram"] \
            -column 0 -row 0 -sticky ew -columnspan 7
    grid [label $np.l1 -text "Data file:"] -column 0 -row 1 
    grid [label $np.t1 -textvariable newhist(rawfile) -bd 2 -relief ridge] \
            -column 1 -row 1 -columnspan 3 -sticky ew
    grid [button $np.b1 -text "Select File" \
            -command "getrawfile $np" \
            ] -column 4 -row 1

    grid [label $np.lbank -text "Select bank" -anchor w] -column 1 -row 2 -sticky w
    grid [frame $np.bank]  -column 2 -row 2 -columnspan 7 -sticky ew

    grid [label $np.l2 -text "Instrument\nParameter file:"] -column 0 -row 3
    grid [label $np.t2 -textvariable newhist(instfile) -bd 2 -relief ridge] \
            -column 1 -row 3 -columnspan 3 -sticky ew
    grid [button $np.b2 -text "Select File" \
            -command "getinstfile $np" \
            ] -column 4 -row 3

    grid [label $np.lset -text "Select set" -anchor w] -column 1 -row 4 -sticky w
    grid [frame $np.set]  -column 2 -row 4 -columnspan 7 -sticky ew

    grid [label $np.l3 -text "Usable data limit:"] -column 0 -row 5 -rowspan 2 
    grid [entry $np.e3 -width 12 -textvariable newhist(2tLimit) \
            ] -column 1 -row 5 -rowspan 2 
    grid [radiobutton $np.cb3 -text "D-min" -variable newhist(LimitMode) \
            -value 0] -column 2 -row 5 -sticky w
    grid [radiobutton $np.cb4 -text "TOF/2-Theta Max" -variable newhist(LimitMode)\
            -value 1] -column 2 -row 6 -sticky w
    
    grid [frame $np.f6] -column 0 -row 7 -columnspan 5 -sticky ew 
    grid [button $np.f6.b6a -text Add \
            -command "addhist $np"] -column 0 -row 0
    bind $np <Return> "addhist $np"
    grid [button $np.f6.b6b -text Cancel \
            -command "destroy $np"] -column 1 -row 0
    grid [button $np.f6.help -text Help -bg yellow \
            -command "MakeWWWHelp expgui3.html AddHist"] \
            -column 2 -row 0 -sticky e
    grid columnconfigure $np.f6 2 -weight 1

    grid [button $np.f6a -text "Run\nRAWPLOT" -command RunRawplot] \
            -column 4 -row 5 -rowspan 2
    
    grid columnconfigure $np 3 -weight 1
    
    wm title $np "add new histogram"

    if {[string trim $newhist(rawfile)] != {}} {
        validaterawfile $np $newhist(rawfile)
    }
    if {[string trim $newhist(instfile)] != {}} {
        validateinstfile $np $newhist(instfile)
    }
    set newhist(banknum) {}
    set newhist(setnum) {}
    #    for {set i 0} {$i<100} {incr i} {set newhist(bank$i) 0}
    #    for {set i 0} {$i<100} {incr i} {set newhist(set$i) 0}

    # set grab, etc.
    putontop $np

    tkwait window $np

    # fix grab...
    afterputontop
}

# convert a file to Win-95 direct access
proc WinCvt {file} {
    global expgui
    if ![file exists $file] {
        tk_dialog .warn "Convert Error" \
                "File $file does not exist" question 0 "OK"
        return
    }

    set tmpname "[file join [file dirname $file] tempfile.xxx]"
    set oldname "[file rootname $file].org"
    if [file exists $oldname] {
        set ans [tk_dialog .warn "OK to overwrite?" \
                "File [file tail $oldname] exists in [file dirname $oldname]. OK to overwrite?" question 0 \
                "Yes" "No"]
        if $ans return
        catch {file delete $oldname}
    }

    if [catch {
        set in [open $file r]
        # needed to test under UNIX
        set out [open $tmpname w]
        fconfigure $out -translation crlf
        set len [gets $in line]
        if {$len > 160} {
            # this is a UNIX file. Hope there are no control characters
            set i 0
            set j 79
            while {$j < $len} {
                puts $out [string range $line $i $j]
                incr i 80
                incr j 80
            }
        } else {
            while {$len >= 0} {
                append line "                                        "
                append line "                                        "
                set line [string range $line 0 79]
                puts $out $line
                set len [gets $in line]
            }
        }
        close $in
        close $out
        file rename $file $oldname
        file rename $tmpname $file
    } errmsg] {
        tk_dialog .warn Notify "Error in conversion:\n$errmsg" warning 0 OK
    }
    return $file
}

proc getrawfile {np} {
    global newhist tcl_platform
    if {$tcl_platform(platform) == "windows"} {
        set inp [
        tk_getOpenFile -parent $np -initialfile $newhist(rawfile) -filetypes {
            {"Data files" .GSAS} {"Data files" .GSA} 
            {"Data files" .RAW}  {"All files" *}
        }
        ]
    } else {
        set inp [
        tk_getOpenFile -parent $np -initialfile $newhist(rawfile) -filetypes {
            {"Data files" .GSA*} {"Data files" .RAW}  
            {"Data files" .gsa*} {"Data files" .raw}  
            {"All files" *}
        } 
        ]
    }
    validaterawfile $np $inp
}

proc validaterawfile {np inp} {
    global tcl_platform expgui newhist
    if {$inp == ""} return
    if [catch {set in [open $inp r]}] {
        tk_dialog .err "Open error" "Unable to open file $inp" \
                error 0 OK
        return 
    }
    set newhist(banklist) {}
    foreach child [winfo children $np.bank] {destroy $child}
    # is this a properly formatted file?
    if {$tcl_platform(platform) == "windows"} {
        # are lines the correct length?

        #--> can we check that lines are terminated CR-LF?

        set i 0
        while {[set len [gets $in line]] > 0} {
            incr i
            if {$len != 80} {
                set ans [tk_dialog .err "Read error" \
                        "File $inp is not direct access. OK to convert?" \
                        error 0 OK QUIT]
                if {$ans == 0} {
                    close $in
                    WinCvt $inp
                    set i 0
                    set in [open $inp r]
                    set line {}
                } else {
                    return
                }
            }
            # scan for BANK lines
            if {[string first BANK $line] == 0} {
                scan $line "BANK%d" num
                lappend newhist(banklist) $num
                # compute last point
                set tmax 0
                catch {
                    scan $line "BANK%d%d%d%s%f%f" num nchan nrec rest start step
                    set tmax [expr ($start + $step*($nchan-1))/100.]
                }
                set newhist(tmax$num) $tmax
            }
            # check for "Instrument parameter file" line
            if {$i == 2 && [string first "Instrument parameter" $line] == 0} {
                validateinstfile $np \
                        [file join [file dirname $inp] \
                        [string trim [string range $line 26 end]]]
            }
        }
    } else {
        # is the file one big record?
        set len [gets $in line]
        # a instrument parameter file should be more than 4 lines
        if {$len <= 4*80} {
            set ans [tk_dialog .err "Read error" \
                    "File $inp is not direct access. OK to convert?" \
                    error 0 OK QUIT]
            if {$ans == 0} {
                close $in
                set oldname ${inp}.original
                file rename $inp $oldname
                if [catch {
                    exec [file join $expgui(gsasexe) convstod] < \
                            $oldname > $inp
                } errmsg] {
                    tk_dialog .warn Notify \
                            "Error in conversion:\n$errmsg" warning 0 OK
                }
                set in [open $inp r]
                set line {}
            } else {
                return
            }
        }
        seek $in 0
        set i 0
        while {[string length [set line [read $in 80]]] == 80} {
            incr i
            # scan for BANK lines
            if {[string first BANK $line] == 0} {
                scan $line "BANK%d" num 
                lappend newhist(banklist) $num
                # compute last point
                set tmax 0
                catch {
                    scan $line "BANK%d%d%d%s%f%f" num nchan nrec rest start step
                    set tmax [expr ($start + $step*($nchan-1))/100.]
                }
                set newhist(tmax$num) $tmax
            }
            # check for "Instrument parameter file" line
            if {$i == 2 && [string first "Instrument parameter" $line] == 0} {
                validateinstfile $np \
                        [file join [file dirname $inp] \
                        [string trim [string range $line 26 end]]]
            }
        }
    }
    # were banks found?
    if {$newhist(banklist) == ""} {
        tk_dialog .err "Read error" \
                "File $inp has no BANK lines. This is not a valid GSAS data file." \
                error 0 OK
        return
    }
    # don't use a full path unless needed
    if {[pwd] == [file dirname $inp]} {
        set newhist(rawfile) [file tail $inp]
    } else {
        set newhist(rawfile) $inp
    }
    set row 0
    set col -1
    foreach i $newhist(banklist) {
        if {$col > 8} {
            set col -1
            incr row
        }
        grid [radiobutton $np.bank.$i -text $i -command SetTmax \
                -variable newhist(banknum) -value $i] \
                -column [incr col] -row $row -sticky w
        # only 1 choice, so set it
        if {[llength $newhist(banklist)] == 1} {
            set newhist(banknum) $i
            SetTmax
        } else {
            set newhist(2tLimit) {}
            set newhist(LimitMode) {}
        }
    }
}

proc SetTmax {} {
    global newhist
    set num $newhist(banknum)
    set newhist(2tLimit) $newhist(tmax$num)
    set newhist(LimitMode) 1
}

proc getinstfile {np} {
    global newhist tcl_platform
    if {$tcl_platform(platform) == "windows"} {
        set inp [
        tk_getOpenFile -parent $np -initialfile $newhist(instfile) -filetypes {
            {"Inst files" .INST} {"Inst files" .INS} 
            {"Inst files" .PRM} {"All files" *}
        }
        ]
    } else {
        set inp [
        tk_getOpenFile -parent $np -initialfile $newhist(instfile) -filetypes {
            {"Inst files" .INS*} {"Inst files" .ins*} 
            {"Inst files" .PRM}  {"Inst files" .prm} 
            {"All files" *}
        }
        ]
    }
    validateinstfile $np $inp
}

proc validateinstfile {np inp} {
    global tcl_platform expgui newhist
    if {$inp == ""} return
    if [catch {set in [open $inp r]}] {
        tk_dialog .err "Open error" "Unable to open file $inp" \
                error 0 OK
        return 
    }
    set newhist(instbanks) {}
    foreach child [winfo children $np.set] {destroy $child}
    # is this a properly formatted file?
    if {$tcl_platform(platform) == "windows"} {
        # are lines the correct length?

        #--> can we check that lines are terminated CR-LF?

        while {[set len [gets $in line]] > 0} {
            if {$len != 80} {
                set ans [tk_dialog .err "Read error" \
                        "File $inp is not direct access. OK to convert?" \
                        error 0 OK QUIT]
                if {$ans == 0} {
                    close $in
                    WinCvt $inp
                    set in [open $inp r]
                    set line {}
                } else {
                    return
                }
            }
            # scan for the INS   BANK line
            if {[string first "INS   BANK" $line] == 0} {
                set newhist(instbanks) \
                        [string trim [string range $line 12 end]]
            }
        }
    } else {
        # is the file one big record?
        set len [gets $in line]
        if {$len <= 80} {
            set ans [tk_dialog .err "Read error" \
                    "File $inp is not direct access. OK to convert?" \
                    error 0 OK QUIT]
            if {$ans == 0} {
                close $in
                set oldname ${inp}.original
                file rename $inp $oldname
                if [catch {
                    exec [file join $expgui(gsasexe) convstod] < \
                            $oldname > $inp
                } errmsg] {
                    tk_dialog .warn Notify \
                            "Error in conversion:\n$errmsg" warning 0 OK
                }
                set in [open $inp r]
                set line {}
            } else {
                return
            }
        }
        seek $in 0
        while {[string length [set line [read $in 80]]] == 80} {
            # scan for the INS   BANK line
            if {[string first "INS   BANK" $line] == 0} {
                set newhist(instbanks) \
                        [string trim [string range $line 12 end]]
            }
        }
    }
    # were banks found?
    if {$newhist(instbanks) == ""} {
        tk_dialog .err "Read error" \
                "File $inp has no INS   BANK line. This is not a valid GSAS Instrument Parameter file." \
                error 0 OK
        return
    }
    # don't use a full path unless needed
    if {[pwd] == [file dirname $inp]} {
        set newhist(instfile) [file tail $inp]
    } else {
        set newhist(instfile) $inp
    }
    set col -1
    set row 0
    for {set i 1} {$i <= $newhist(instbanks)} {incr i} {
        if {$col > 8} {
            set col -1
            incr row
        }
        grid [radiobutton $np.set.$i -text $i \
                -variable newhist(setnum) -value $i] \
                -column [incr col] -row $row -sticky w

        if {$newhist(instbanks) == 1} {set newhist(setnum) $i}
    }
}

proc addhist {np} {
    global expgui newhist tcl_platform
    # validate the input
    set err {}
    if {[string trim $newhist(rawfile)] == ""} {
        append err "  No data file specified\n"
    }
    if {[string trim $newhist(instfile)] == ""} {
        append err "  No instrument parameter file specified\n"
    }
    if {[string trim $newhist(banknum)] == ""} {
            append err "  Bank number must be specified\n"
    } elseif {[catch {expr $newhist(banknum)}]} {
            append err "  Bank number is not valid\n"
    }
    if {[string trim $newhist(setnum)] == ""} {
        append err "  Parameter set number must be specified\n"
    } elseif {[catch {expr $newhist(setnum)}]} {
        append err "  Parameter set number is not valid\n"
    }
    if {[string trim $newhist(2tLimit)] == ""} {
        append err "  2Theta/d-space limit must be specified\n"
    } elseif {[catch {expr $newhist(2tLimit)}]} {
        append err "  The 2Theta/d-space limit is not valid\n"
    }
    if {[string trim $newhist(LimitMode)] == ""} {
        append err "  Please choose between either a 2Theta or d-space limit\n"
    }

    if {$err != ""} {
#       tk_dialog .phaseerr "Add Histogram Error" \
#               "The following error(s) were found in your input:\n$err" \
#               error 0 "OK" 
        MyMessageBox -parent $np -title  "Add Histogram Error" \
                -message "The following error(s) were found in your input:\n$err" \
                -icon error -type ok -default ok \
                -helplink "expgui3.html AddHistErr"
        return
    }

    # ok do it!
    set fp [open exptool.in w]
    puts $fp "H"
    if {$tcl_platform(platform) == "windows"} {
        puts $fp [file attributes $newhist(rawfile) -shortname]
        puts $fp [file attributes $newhist(instfile) -shortname]
    } else {
        puts $fp $newhist(rawfile)
        puts $fp $newhist(instfile)
    }
    puts $fp $newhist(banknum)
    puts $fp $newhist(setnum)
    if {$newhist(LimitMode)} {
        puts $fp "T"
    } else {
        puts $fp "D"
    }
    puts $fp "$newhist(2tLimit)"
    puts $fp "/"
    puts $fp "X"
    puts $fp "X"
    close $fp
    global tcl_platform
    # Save the current exp file
    savearchiveexp
    # disable the file changed monitor
    set expgui(expModifiedLast) 0
    set expnam [file root [file tail $expgui(expfile)]]
    catch {
        if {$tcl_platform(platform) == "windows"} {
            exec [file join $expgui(gsasexe) exptool.exe] $expnam \
                    < exptool.in >& exptool.out
        } else {
            exec [file join $expgui(gsasexe) exptool] $expnam \
                    < exptool.in >& exptool.out
        }
    } errmsg
    # load the revised exp file
    loadexp $expgui(expfile)
    set fp [open exptool.out r]
    set out [read $fp]
    close $fp
    destroy $np
    if {$errmsg != ""} {
        append errmsg "\n" $out
    } else {
        set errmsg $out
    }
    if {$expgui(showexptool)} {
        ShowBigMessage \
                $np \
                "Please review the result from adding the phase" \
                $errmsg
    }
    file delete exptool.in exptool.out
}

proc RunRawplot {} {
    global newhist tcl_platform
    # for Windows put a message on top, in case file names must be shortened
    if {$tcl_platform(platform) == "windows"} {
        set f1 {}
        catch {set f1 [file nativename \
                    [file attributes $newhist(rawfile) -shortname]]}
        set f2 {}
        catch {set f2 [file nativename \
                [file attributes $newhist(instfile) -shortname]]}
        if {$f1 != "" || $f2 != ""} {
            set msg "Note: input to RAWPLOT\n"
            if {$f1 != ""} {append msg "data file: $f1\n"}
            if {$f2 != ""} {append msg "instrument file: $f2"}
            MyMessageBox -icon info -message $msg -parent .
        }
    }
    # start RAWPLOT
    runGSASwEXP rawplot 1
}

proc MakeAddAtomsBox {phase "atomlist {}"} {
    global expmap expgui

    # is there room for more atoms? Well, we will check this someday
    if {$phase == ""} return
    if {[llength $phase] != 1} return

    set top .newatoms
    catch {destroy $top}
    toplevel $top
    bind $top <Key-F1> "MakeWWWHelp expgui2.html addatoms"

    grid [label $top.l1 -relief groove -bd 4 -anchor center\
            -text "Adding atoms to phase #$phase"] \
            -column 0 -row 0 \
            -sticky we -columnspan 10
    
    grid [canvas $top.canvas \
            -scrollregion {0 0 5000 500} -width 0 -height 250 \
            -yscrollcommand "$top.scroll set"] \
            -column 0 -row 2 -columnspan 4 -sticky nsew
    grid columnconfigure $top 3 -weight 1
    grid rowconfigure $top 2 -weight 1
    grid rowconfigure $top 1 -pad 5
    scrollbar $top.scroll \
            -command "$top.canvas yview"
    frame $top.canvas.fr
    $top.canvas create window 0 0 -anchor nw -window $top.canvas.fr

    set np $top.canvas.fr
    set row 0
    set col 0
    foreach i {Atom\ntype Name x y z Occ Uiso Use} {
        grid [label $np.l_${row}$i -text $i] -column [incr col] -row $row
    }

    set expgui(SetAddAtomsScroll) 0
    set i [llength $atomlist]
    if {$i == 0} {incr i}
    for {set j 0} {$j < $i} {incr j} {
        MakeAddAtomsRow $top
    }
    set row 0
    foreach item $atomlist {
        incr row
        foreach val $item w {n x y z t o u} {
            if {$val != ""} {
                $np.e${row}$w delete 0 end
                $np.e${row}$w insert end $val
            }
        }
    }
    bind $top <Configure> "SetAddAtomsScroll $top"
    grid rowconfigure $top 3 -min 10
    grid [button $top.b1 -text "Add Atoms"\
            -command "addatom $phase $top"] -column 0 -row 5 -sticky w
    bind $top <Return> "addatom $phase $top"
    grid [button $top.b2 -text Cancel \
            -command "destroy $top"] -column 1 -row 5 -sticky w
    grid [button $top.help -text Help -bg yellow \
            -command "MakeWWWHelp expgui2.html addatoms"] \
            -column 0 -columnspan 2 -row 4

    # get the input formats if not already defined
    GetImportFormats
    if {[llength $expgui(importFormatList)] > 0} {
        grid [frame $top.fr -bd 4 -relief groove] \
                -column 3 -row 5 -columnspan 2 -sticky e
        grid [button $top.fr.b3 -text "Import atoms from: " \
                -command "ImportAtoms \$expgui(importFormat) $top"] \
                -column 0 -row 0 -sticky e
        eval tk_optionMenu $top.fr.b4 expgui(importFormat) \
                $expgui(importFormatList)
        grid $top.fr.b4 -column 1 -row 0 -sticky w
        grid rowconfig $top.fr 0 -pad 10
        grid columnconfig $top.fr 0 -pad 10
        grid columnconfig $top.fr 1 -pad 10
    }

    grid [button $top.b3 -text  "More atom boxes" \
            -command "MakeAddAtomsRow $top"] -column 3 \
            -columnspan 2 -row 4 -sticky e
    
    wm title $top "add new atom"

    # set grab, etc.
    putontop $top

    tkwait window $top

    # fix grab...
    afterputontop
}

proc MakeAddAtomsRow {top} {
    set np $top.canvas.fr
    set col -1
    set row 1
    # find an empty row
    while {![catch {grid info $np.e${row}t}]} {incr row}
    grid [label $np.e${row}num -text $row] -column [incr col]  -row $row
    grid [entry $np.e${row}t -width 5] -column [incr col]  -row $row
    grid [entry $np.e${row}n -width 8] -column [incr col]  -row $row
    foreach i {x y z o u} {
        grid [entry $np.e${row}$i -width 9] -column [incr col] -row $row
    }
    grid [checkbutton $np.e${row}use -variable expgui(UseAtom$row)] \
            -column [incr col] -row $row
    # default occupancy
    $np.e${row}o delete 0 end
    $np.e${row}o insert end 1.0
    # default Uiso
    $np.e${row}u delete 0 end
    $np.e${row}u insert end 0.025
    # default label
    $np.e${row}n delete 0 end
    $np.e${row}n insert end (default)
    # use by default
    $np.e${row}use select

    SetAddAtomsScroll $top
    return $row
}

proc SetAddAtomsScroll {top} {
    global expgui
    if $expgui(SetAddAtomsScroll) return
    # prevent reentrance
    set expgui(SetAddAtomsScroll) 1
    update
    set sizes [grid bbox $top.canvas.fr]
    $top.canvas config -scrollregion $sizes -width [lindex $sizes 2]
    # use the scroll for BIG atom lists
    if {[lindex $sizes 3] > [winfo height $top.canvas]} {
        grid $top.scroll -sticky ns -column 4 -row 2
    } else {
        grid forget $top.scroll 
    }
    update
    set expgui(SetAddAtomsScroll) 0
}

proc addatom {phase top} {
    global expgui env
    set np $top.canvas.fr
    set row 0
    # loop over the defined rows
    set err {}
    set atomlist {}
    while {![catch {grid info $np.e[incr row]t}]} {
        if !{$expgui(UseAtom$row)} continue
        # ignore blank entries
        set line {}
        foreach i {t x y z} {
            append line [string trim [$np.e${row}$i get]]
        }
        if {$line == ""} continue
        # validate the input
        if {[set type [string trim [$np.e${row}t get]]] == ""} {
            append err "  line $row: No atom type specified\n"
        }
        set name [string trim [$np.e${row}n get]]
        if {$name == "(default)"} {set name "/"}
        if {$name == ""} {set name "/"}
        foreach i {x y z o u} n {x y z Occ Uiso} {
            if {[set $i [string trim [$np.e${row}$i get]]] == ""} {
                append err "  line $row: No value specified for $n\n"
            } elseif {[catch {expr [set $i]}]} {
                append err "  line $row: The value for $n is invalid\n"
            }
        }
        lappend atomlist "$type $x $y $z $o $name I $u"
    }   
    if {$err != ""} {
        MyMessageBox -icon warning -message "Note Errors:\n$err" -parent $top
        return
    }
    if {[llength $atomlist] == 0} {
        MyMessageBox -icon warning -message "No atoms to load!" -parent $top
        return
    }
    # ok add the atoms!
    set fp [open exptool.in w]
    puts $fp "A"
    puts $fp $phase
    # number of atoms
    puts $fp [llength $atomlist]
    foreach atomline $atomlist {
        puts $fp $atomline
    }
    close $fp
    # needed in UNIX
    set env(ATOMDATA) [file join $expgui(gsasdir) data atmdata.dat]
    # needed in Windows
    set env(GSAS) [file nativename $expgui(gsasdir)]

    global tcl_platform
    # Save the current exp file
    savearchiveexp
    # disable the file changed monitor
    set expgui(expModifiedLast) 0
    set expnam [file root [file tail $expgui(expfile)]]
    catch {
        if {$tcl_platform(platform) == "windows"} {
            exec [file join $expgui(gsasexe) exptool.exe] $expnam \
                    < exptool.in >& exptool.out
        } else {
            exec [file join $expgui(gsasexe) exptool] $expnam \
                    < exptool.in >& exptool.out
        }
    } errmsg
    # load the revised exp file
    loadexp $expgui(expfile)
    set fp [open exptool.out r]
    set out [read $fp]
    close $fp
    destroy $top
    if {$errmsg != ""} {
        append errmsg "\n" $out
    } else {
        set errmsg $out
    }
    if {$expgui(showexptool)} {
        ShowBigMessage \
                $top \
                "Please review the result from adding the atom(s)" \
                $errmsg
    }
    file delete exptool.in exptool.out
}

#----------------------------------------------
# commands to modify a group of selected atoms |
#----------------------------------------------

# make the dialog to choose an action
proc MakeXformAtomsBox {phase} {
    global expgui expmap
    set numberList {}
    set p $expgui(curPhase)
    foreach AtomIndex $expgui(selectedatomlist) {
        # get atom number & phase
        set tuple [lindex $expmap(atomlistboxcontents) $AtomIndex]
        lappend numberList [lindex $tuple 0]
    }
    if {$numberList == ""} return
    if {[llength $numberList] > 1} {
        set suffix s
        set suffixy "ies"
    } else {
        set suffix ""
        set suffixy "y"
    }
    set w .global
    catch {destroy $w}
    toplevel $w
    wm title $w "Edit Atomic Parameter -- phase #$phase"
    bind $w <Key-F1> "MakeWWWHelp expgui2.html xform"
    # this needs to track by phase
    grid [label $w.0 \
            -text "Modifying atom${suffix} [CompressList $numberList] Phase $phase" \
            -bg yellow -anchor center] -row 0 -column 0 -columnspan 10 \
            -sticky nsew
    grid rowconfigure $w 0 -pad 5
    grid rowconfigure $w 1 -minsize 2

    grid [TitleFrame $w.1 -bd 6 -relief groove -text "Modify coordinates"] \
            -row 2 -column 0 -columnspan 10 -sticky news
    set w1 [$w.1 getframe]
    set row 0
    foreach v {x y z} {
        incr row
        set col -1
        grid [label $w1.l$v -text "new $v   =   "] -column [incr col] -row $row
        foreach o {x y z} {
            grid [entry $w1.e${v}${o} -width 6] -column [incr col] -row $row
            $w1.e${v}${o} delete 0 end
            if {$v == $o} {
                $w1.e${v}${o} insert end "1.0"
            } else {
                $w1.e${v}${o} insert end "0."
            }
            grid [label $w1.p${v}${o} -text " $o  +  "] \
                    -column [incr col] -row $row
        }
        grid [entry $w1.e${v} -width 6] -column [incr col] -row $row
        $w1.e${v} delete 0 end
        $w1.e${v} insert end "0."
    }
    grid [button $w1.do -text "Transform Coordinates" \
            -command "XformAtomsCoord $phase [list $numberList] $w1" \
            ] -row [incr row] -column 0 -columnspan 10

    grid rowconfigure $w 3 -minsize 5
    grid [TitleFrame $w.4 -bd 6 -relief groove -text "Modify occupanc${suffixy}"] \
            -row 4 -column 0 -columnspan 10 -sticky news
    set w2 [$w.4 getframe]
    grid [label $w2.1 -text "Occupancy: "] -row 1 -column 0
    grid [entry $w2.e -width 10] -column 1 -row 1
    $w2.e delete 0 end
    $w2.e insert end 1.0
    grid columnconfigure $w2 2 -weight 1
    grid [button $w2.do -text "Set Occupanc${suffixy}" \
            -command "XformAtomsOcc $phase [list $numberList] $w2" \
            ] -row 2 -column 0 -columnspan 10

    grid rowconfigure $w 5 -minsize 5
    grid [TitleFrame $w.6 -bd 6 -relief groove \
            -text "Modify Displacement Parameter$suffix"] \
            -row 6 -column 0 -columnspan 10 -sticky news
    set w2 [$w.6 getframe]
    grid [label $w2.1 -text "Uiso or Uequiv: "] -row 1 -column 0
    grid [entry $w2.e -width 10] -column 1 -row 1
    $w2.e delete 0 end
    $w2.e insert end 0.025
    grid columnconfigure $w2 2 -weight 1
    grid [button $w2.do -text "Set U" \
            -command "XformAtomsU $phase [list $numberList] $w2" \
            ] -row 2 -column 0 -columnspan 10
    grid [frame $w2.f] -row 3 -column 0 -columnspan 10
    grid [button $w2.f.iso -text "Set Isotropic" \
            -command "XformAtomsU $phase [list $numberList] iso" \
            ] -row 0 -column 0
    grid [button $w2.f.aniso -text "Set Anisotropic" \
            -command "XformAtomsU $phase [list $numberList] aniso" \
            ] -row 0 -column 1

    grid rowconfigure $w 5 -minsize 5
    grid [TitleFrame $w.8 -bd 6 -relief groove \
            -text "Erase Atom$suffix"] \
            -row 8 -column 0 -columnspan 10 -sticky news
    set w2 [$w.8 getframe]
    grid [button $w2.do -text "Erase Atom${suffix}" \
            -command "EraseAtoms $phase [list $numberList] $w" \
            ] -row 2 -column 0 -columnspan 10


    grid rowconfigure $w 9 -minsize 5
    grid [frame $w.b] -row 10 -column 0 -columnspan 10 -sticky ew
    pack [button $w.b.3 -text Close -command "destroy $w"] -side left \
            -padx 5 -pady 5
    pack [button $w.b.help -text Help -bg yellow \
            -command "MakeWWWHelp expgui2.html xform"] -side right \
            -padx 5 -pady 5
    bind $w <Return> "destroy $w"

    # force the window to stay on top
    putontop $w
    focus $w.b.3
    tkwait window $w
    afterputontop
    # if there are selected atoms, reset their display
    if {[llength $expgui(selectedatomlist)] != 0} editRecord
}

# transform the coordinates
proc XformAtomsCoord {phase numberList w1} {
    global expgui
    # get the matrix
    foreach v {x y z} {
        foreach o {x y z} {
            set matrix(${v}${o}) [$w1.e${v}${o} get]
        }
        set matrix(${v}) [$w1.e${v} get]
    }
    foreach atom $numberList {
        foreach v {x y z} {
            set $v [atominfo $phase $atom $v]
        }
        foreach v {x y z} {
            set new$v $matrix(${v})
            foreach o {x y z} {
                set new$v [expr [set new$v] + $matrix(${v}${o})*[set $o]]
            }
            atominfo $phase $atom $v set [set new$v]
        }
        incr expgui(changed)
    }
    DisplayAllAtoms noreset
}

# set the occupancies to a single value
proc XformAtomsOcc {phase numberList w2} {
    global expgui
    # get the value
    set val [$w2.e get]
    foreach atom $numberList {
        atominfo $phase $atom frac set $val
        incr expgui(changed)
    }
    DisplayAllAtoms noreset
}

# transform Uiso or Uij; if anisotropic set Uequiv to Uij
proc XformAtomsU {phase numberList w2} {
    global expgui
    if {$w2 == "iso"} {
        foreach atom $numberList {
            if {[atominfo $phase $atom temptype] != "I"} {
                atominfo $phase $atom temptype set I
            }
        }
    } elseif {$w2 == "aniso"} {
        foreach atom $numberList {
            if {[atominfo $phase $atom temptype] == "I"} {
                atominfo $phase $atom temptype set A
            }
        }
    } else {
        # get the value
        set val [$w2.e get]
        foreach atom $numberList {
            if {[atominfo $phase $atom temptype] == "I"} {
                atominfo $phase $atom Uiso set $val
            } else {
                atominfo $phase $atom U11 set $val
                atominfo $phase $atom U22 set $val
                atominfo $phase $atom U33 set $val
                atominfo $phase $atom U12 set 0.0
                atominfo $phase $atom U13 set 0.0
                atominfo $phase $atom U23 set 0.0
            }
            incr expgui(changed)
        }
    }
    DisplayAllAtoms noreset
}

# confirm and erase atoms
proc EraseAtoms {phase numberList w2} {
    global expgui
    if {[llength $numberList] <= 0} return
    # make a list of atoms
    foreach atom $numberList {
        append atomlist "\n\t$atom  [atominfo $phase $atom label]"
    }
    set msg "OK to remove the following [llength $numberList] atoms from phase $phase:$atomlist"
    set val [MyMessageBox -parent $w2 -type okcancel -icon warning \
            -default cancel -title "Confirm Erase" -message $msg]
    if {$val == "ok"} {
        foreach atom $numberList {
            EraseAtom $atom $phase
            incr expgui(changed)
        }
        mapexp
        DisplayAllAtoms
        destroy $w2
    }
}

proc ImportPhase {format np} {
    global expgui
    foreach item $expgui(extensions_$format) {
        lappend typelist [list $format $item]
    }
    lappend typelist [list "All files" *]
    set file [tk_getOpenFile -parent $np -filetypes $typelist]
    if {![file exists $file]} return
    # read in the file
    set input [$expgui(proc_$format) $file]
    catch {
        $np.bf.b1 config -text "Continue" -command "addphase $np; AddAtomsList"
        bind $np <Return> "addphase $np; AddAtomsList"
    }
    catch {
        $np.t1 delete 0 end
        $np.t1 insert end "from $file"
    }
    $np.t2 delete 0 end
    $np.t2 insert end [lindex $input 0]
    foreach i {.e1a .e1b .e1c .e2a .e2b .e2g} val [lindex $input 1] {
        $np.f$i delete 0 end
        $np.f$i insert end $val
    }
    set expgui(coordList) [lindex $input 2]
    set msg [lindex $input 3]
    if {$msg != ""} {
        grid [label $np.msg -text $msg -fg red -justify left -bd 4 -relief raised] \
                -column 0 -columnspan 8 -row 20 -sticky ew
    }
}

proc ImportAtoms {format top} {
    global expgui
    foreach item $expgui(extensions_$format) {
        lappend typelist [list $format $item]
    }
    lappend typelist [list "All files" *]
    set file [tk_getOpenFile -parent $top -filetypes $typelist]
    if {![file exists $file]} return
    # read in the file
    set input [$expgui(proc_$format) $file]
    # add atoms to table
    foreach item [lindex $input 2] {
        set row [MakeAddAtomsRow $top]
        set np $top.canvas.fr
        foreach val $item w {n x y z t o u} {
            if {$val != ""} {
                $np.e${row}$w delete 0 end
                $np.e${row}$w insert end $val
            }
        }
    }
}

proc AddAtomsList {} {
    global expgui expmap
    # find the new phase
    set phase {}
    foreach p $expmap(phaselist) {
        if {[lsearch $expgui(oldphaselist) $p] == -1} {
            set phase $p
            break
        }
    }
    if {$phase == ""} return
    MakeAddAtomsBox $phase $expgui(coordList)
}

# get the input formats by sourcing files named import_*.tcl
proc GetImportFormats {} {
    global expgui tcl_platform
    # only needs to be done once
    if [catch {set expgui(importFormatList)}] {
        set filelist [glob -nocomplain [file join $expgui(scriptdir) import_*.tcl]]
        foreach file $filelist {
            source $file
            lappend expgui(importFormatList) $description
            if {$tcl_platform(platform) == "unix"} {
                set extensions "[string tolower $extensions] [string toupper $extensions]"
            }
            set expgui(extensions_$description) $extensions
            set expgui(proc_$description) $procname
        }
    }
}

proc MakeReplacePhaseBox {} {
    global expmap expgui tcl_platform

    set expgui(coordList) {}
    # ignore the command if no phase is selected
    foreach p {1 2 3 4 5 6 7 8 9} {
        if {[lsearch $expmap(phaselist) $expgui(curPhase)] == -1} {
            return
        }
    }

    set top .newphase
    catch {destroy $top}
    toplevel $top
    bind $top <Key-F1> "MakeWWWHelp expgui2.html replacephase"

    grid [label $top.l1 -text "Replacing phase #$expgui(curPhase)" \
            -bg yellow -anchor center] -column 0 -columnspan 8 -row 0 -sticky ew
    grid [label $top.l3a -text "Current Space Group: "] \
            -column 0 -row 2 -columnspan 2 -sticky e
    grid [label $top.l3b -text [phaseinfo $expgui(curPhase) spacegroup]\
            -bd 4 -relief groove] \
            -column 2 -row 2  -sticky ew
    grid [label $top.l4 -text "New Space Group: "] \
            -column 0 -row 3 -columnspan 2 -sticky e
    grid [entry $top.t2 -width 12] -column 2 -row 3 -sticky w
    grid [radiobutton $top.r1 -text "Reenter current atoms"\
            -variable expgui(DeleteAllAtoms) -value 0] \
            -column 1 -row 4 -columnspan 8 -sticky w
    grid [radiobutton $top.r2 -text "Delete current atoms" \
            -variable expgui(DeleteAllAtoms) -value 1] \
            -column 1 -row 5 -columnspan 8 -sticky w
    
    grid [frame $top.f -bd 4 -relief groove] \
            -column 3 -row 2 -columnspan 3 -rowspan 4
    set col -1
    foreach i {a b c} {
        grid [label $top.f.l1$i -text " $i "] -column [incr col] -row 1
        grid [entry $top.f.e1$i -width 12] -column [incr col]  -row 1
        $top.f.e1$i delete 0 end
        $top.f.e1$i insert 0 [phaseinfo $expgui(curPhase) $i]
    }
    set col -1
    foreach i {a b g} var {alpha beta gamma} {
        grid [label $top.f.l2$i -text $i -font symbol] -column [incr col] -row 2
        grid [entry $top.f.e2$i -width 12] -column [incr col]  -row 2
        $top.f.e2$i delete 0 end
        $top.f.e2$i insert 0 [phaseinfo $expgui(curPhase) $var]
    } 

    grid [button $top.b1 -text Continue \
            -command "replacephase1 $top $expgui(curPhase)"] \
            -column 0 -row 6 -sticky w
    bind $top <Return> "replacephase1 $top $expgui(curPhase)"
    grid [button $top.b2 -text Cancel \
            -command "destroy $top"] -column 1 -row 6 -sticky w
    grid [button $top.help -text Help -bg yellow \
            -command "MakeWWWHelp expgui2.html replacephase"] \
            -column 2 -row 6

    # get the input formats if not already defined
    GetImportFormats
    if {[llength $expgui(importFormatList)] > 0} {
        grid [frame $top.fr -bd 4 -relief groove] \
                -column 2 -row 6 -columnspan 8 -sticky e
        grid [button $top.fr.b3 -text "Import phase from: " \
                -command "ImportPhase \$expgui(importFormat) $top"] \
                -column 0 -row 0 -sticky e
        eval tk_optionMenu $top.fr.b4 expgui(importFormat) \
                $expgui(importFormatList)
        grid $top.fr.b4 -column 1 -row 0 -sticky w
        grid rowconfig $top.fr 0 -pad 10
        grid columnconfig $top.fr 0 -pad 10
        grid columnconfig $top.fr 1 -pad 10
#       grid columnconfig $top 4 -weight 1
        grid columnconfig $top 2 -weight 1
    }
    
    wm title $top "Replace phase $expgui(curPhase)"

    # set grab, etc.
    putontop $top

    tkwait window $top

    # fix grab...
    afterputontop
}

proc replacephase1 {top phase} {
    # validate cell & space group & save to pass
    global expgui expmap
    set expgui(SetAddAtomsScroll) 0
    # validate the input
    set err {}
    set spg [$top.t2 get]
    if {[string trim $spg] == ""} {
        append err "  Space group cannot be blank\n"
    }
    set cell {}
    foreach i {a b c a b g} lbl {a b c alpha beta gamma} n {1 1 1 2 2 2} {
        set $lbl [$top.f.e${n}$i get]
        if {[string trim [set $lbl]] == ""} {
            append err "  $lbl cannot be blank\n"
        } elseif {[catch {expr [set $lbl]}]} {
            append err "  [set $lbl] is not valid for $lbl\n"
        }
        lappend cell [set $lbl]
    }

    if {$err != ""} {
        tk_dialog .phaseerr "Replace Phase Error" \
                "The following error(s) were found in your input:\n$err" \
                error 0 "OK" 
        return
    }

    # check the space group
    set fp [open spg.in w]
    puts $fp "N"
    puts $fp "N"
    puts $fp $spg
    puts $fp "Q"
    close $fp
    global tcl_platform
    catch {
        if {$tcl_platform(platform) == "windows"} {
            exec [file join $expgui(gsasexe) spcgroup.exe] < spg.in >& spg.out
        } else {
            exec [file join $expgui(gsasexe) spcgroup] < spg.in >& spg.out
        }
    }
    set fp [open spg.out r]
    set out [read $fp]
    close $fp
    # attempt to parse out the output (fix up if parse did not work)
    if {[regexp "space group symbol.*>(.*)Enter a new space group symbol" \
            $out a b ] != 1} {set b $out}
    if {[string first Error $b] != -1} {
        # got an error, show it
        ShowBigMessage \
                 $top.error \
                 "Error processing space group\nReview error message below" \
                 $b
        return
    } else {
        # show the result and confirm
        set opt [ShowBigMessage \
                $top.check \
                "Check the symmetry operators in the output below" \
                $b \
                {Continue Redo} ]
        if {$opt > 1} return
    }
    file delete spg.in spg.out
    # draw coordinates box
    eval destroy [winfo children $top]
    grid [label $top.l1 -relief groove -bd 4 -anchor center\
            -text "Atom list for phase #$phase"] \
            -column 0 -row 0 \
            -sticky we -columnspan 10
    grid [canvas $top.canvas \
            -scrollregion {0 0 5000 500} -width 0 -height 250 \
            -yscrollcommand "$top.scroll set"] \
            -column 0 -row 2 -columnspan 4 -sticky nsew
    grid columnconfigure $top 3 -weight 1
    grid rowconfigure $top 2 -weight 1
    grid rowconfigure $top 1 -pad 5
    scrollbar $top.scroll \
            -command "$top.canvas yview"
    frame $top.canvas.fr
    $top.canvas create window 0 0 -anchor nw -window $top.canvas.fr

    set np $top.canvas.fr
    set row 0
    set col 0
    foreach i {Atom\ntype Name x y z Occ Uiso Use} {
        grid [label $np.l_${row}$i -text $i] -column [incr col] -row $row
    }

    # add the old atoms, if appropriate
    if {!$expgui(DeleteAllAtoms)} {
        # loop over all atoms
        foreach atom $expmap(atomlist_$phase) {
            set row [MakeAddAtomsRow $top]
            # add all atoms in the current phase to the list
            foreach w {n x y z t o} var {label x y z type frac} {
                $np.e${row}$w delete 0 end
                $np.e${row}$w insert end [atominfo $phase $atom $var]
            }
            $np.e${row}u delete 0 end
            if {[atominfo $phase $atom temptype] == "I"} {
                $np.e${row}u insert end [atominfo $phase $atom Uiso]
            } else {
                $np.e${row}u insert end [expr ( \
                        [atominfo $phase $atom U11] + \
                        [atominfo $phase $atom U22] + \
                        [atominfo $phase $atom U33]) / 3.]
            }
        }
    }

    # add coordinates that have been read in, if any
    foreach item $expgui(coordList) {
        set row [MakeAddAtomsRow $top]
        foreach val $item w {n x y z t o u} {
            if {$val != ""} {
                $np.e${row}$w delete 0 end
                $np.e${row}$w insert end $val
            }
        }
    }
    # a blank spot in the table
    MakeAddAtomsRow $top

    bind $top <Configure> "SetAddAtomsScroll $top"
    grid rowconfigure $top 3 -min 10
    grid [button $top.b1 -text "Continue"\
            -command "replacephase2 $phase $top [list $spg] [list $cell]"] \
            -column 0 -row 5 -sticky w
    bind $top <Return> "replacephase2 $phase $top [list $spg] [list $cell]"
    grid [button $top.b2 -text Cancel \
            -command "destroy $top"] -column 1 -row 5 -sticky w
    if {[llength $expgui(importFormatList)] > 0} {
        grid [frame $top.fr -bd 4 -relief groove] \
                -column 3 -row 5 -columnspan 2 -sticky e
        grid [button $top.fr.b3 -text "Import atoms from: " \
                -command "ImportAtoms \$expgui(importFormat) $top"] \
                -column 0 -row 0 -sticky e
        eval tk_optionMenu $top.fr.b4 expgui(importFormat) \
                $expgui(importFormatList)
        grid $top.fr.b4 -column 1 -row 0 -sticky w
        grid rowconfig $top.fr 0 -pad 10
        grid columnconfig $top.fr 0 -pad 10
        grid columnconfig $top.fr 1 -pad 10
    }

    grid [button $top.b3 -text  "More atom boxes" \
            -command "MakeAddAtomsRow $top"] -column 3 \
            -columnspan 2 -row 4 -sticky e
    
    wm title $top "Replacing phase: Enter atoms"
    SetAddAtomsScroll $top

    # fix grab for old window
    afterputontop
    # set grab, etc.
    putontop $top
}

proc replacephase2 {phase top spg cell} {
    global expgui expmap env
    # validate coordinates
    set np $top.canvas.fr
    set row 0
    # loop over the defined rows
    set err {}
    set atomlist {}
    while {![catch {grid info $np.e[incr row]t}]} {
        if !{$expgui(UseAtom$row)} continue
        # ignore blank entries
        set line {}
        foreach i {t x y z} {
            append line [string trim [$np.e${row}$i get]]
        }
        if {$line == ""} continue
        # validate the input
        if {[set type [string trim [$np.e${row}t get]]] == ""} {
            append err "  line $row: No atom type specified\n"
        }
        set name [string trim [$np.e${row}n get]]
        if {$name == "(default)"} {set name "/"}
        if {$name == ""} {set name "/"}
        foreach i {x y z o u} n {x y z Occ Uiso} {
            if {[set $i [string trim [$np.e${row}$i get]]] == ""} {
                append err "  line $row: No value specified for $n\n"
            } elseif {[catch {expr [set $i]}]} {
                append err "  line $row: The value for $n is invalid\n"
            }
        }
        lappend atomlist "$type $x $y $z $o $name I $u"
    }   
    if {$err != ""} {
        MyMessageBox -icon warning -message "Note Errors:\n$err" -parent $top
        return
    }
    if {[llength $atomlist] == 0} {
        MyMessageBox -icon warning -message "No atoms to load!" -parent $top
        return
    }

    pleasewait "updating phase"
    # replace spacegroup and cell
    phaseinfo $phase spacegroup set $spg
    foreach val $cell var {a b c alpha beta gamma} {
        phaseinfo $phase $var set $val
    }
    # delete all atoms
    foreach i $expmap(atomlist_$phase) {
        EraseAtom $i $phase
    }
    incr expgui(changed) 8
    # write new atoms from table as input to exptool
    set fp [open exptool.in w]
    puts $fp "A"
    puts $fp $phase
    # number of atoms
    puts $fp [llength $atomlist]
    foreach atomline $atomlist {
        puts $fp $atomline
    }
    close $fp
    # needed in UNIX
    set env(ATOMDATA) [file join $expgui(gsasdir) data atmdata.dat]
    # needed in Windows
    set env(GSAS) [file nativename $expgui(gsasdir)]

    global tcl_platform
    # Save the current exp file
    savearchiveexp
    # disable the file changed monitor
    set expgui(expModifiedLast) 0
    set expnam [file root [file tail $expgui(expfile)]]
    catch {
        if {$tcl_platform(platform) == "windows"} {
            exec [file join $expgui(gsasexe) exptool.exe] $expnam \
                    < exptool.in >& exptool.out
        } else {
            exec [file join $expgui(gsasexe) exptool] $expnam \
                    < exptool.in >& exptool.out
        }
    } errmsg
    # load the revised exp file
    loadexp $expgui(expfile)
    set fp [open exptool.out r]
    set out [read $fp]
    close $fp
    if {$errmsg != ""} {
        append errmsg "\n" $out
    } else {
        set errmsg $out
    }
    donewait 
    if {$expgui(showexptool)} {
        ShowBigMessage \
                $top \
                "Please review the result from adding the atom(s)" \
                $errmsg
    }
    file delete exptool.in exptool.out
    destroy $top
}