Changeset 1219

Timestamp:

Aug 19, 2012 1:24:43 PM (8 years ago)

Author:

toby

Message:

Major new release: bug fixes for rigid bodies; Split Restraints from Constraints; add chemistry restraints; edit f' & f; fixes for fixing atoms; start work on Absorption constraints and interface for Fourier maps

Location:

trunk

Files:

• addcmds.tcl (modified) (3 diffs)
• anomal.tcl (added)
• atomcons.tcl (modified) (4 diffs)
• chemrest.tcl (added)
• distrest.tcl (modified) (5 diffs)
• expgui (modified) (14 diffs)
• gsascmds.tcl (modified) (2 diffs)
• rbimport_zmatrix.tcl (modified) (1 diff)
• readexp.tcl (modified) (10 diffs)
• rigid.tcl (modified) (17 diffs)

trunk/addcmds.tcl

@@ -1962 +1962 @@
     if {[lindex $expmap(phasetype) [expr {$p - 1}]] != 4} {
         grid [TitleFrame $w.10 -bd 6 -relief groove \
-                -text "Fix Atom$suffix Coordinates"] \
-                -row 9 -column 0 -columnspan 10 -sticky news
+                  -text "Fix Coordinates for Atom$suffix"] \
+            -row 9 -column 0 -columnspan 10 -sticky news
         set fix [$w.10 getframe]
-        Fix_Initialize $numberList
+        # set button labels
+        set ::fixbtn_lbl(X) [Fix_State $phase $numberList X]
+        set ::fixbtn_lbl(Y) [Fix_State $phase $numberList Y]
+        set ::fixbtn_lbl(Z) [Fix_State $phase $numberList Z]
 
         label $fix.xlab -text "  x  " -width 8
@@ -1975 +1978 @@
 
 
-        button $fix.x -text "$::fix_state_X" -width 8 \
-               -command "Fix_Atoms $phase [list $numberList] X $fix.x;
-               Fix_Write
-               DisplayAllAtoms $phase"
-
-        button $fix.y -text "$::fix_state_Y" -width 8 \
-                -command "Fix_Atoms $phase [list $numberList] Y $fix.y
-                Fix_Write
-                DisplayAllAtoms $phase"
-        button $fix.z -text "$::fix_state_Z" -width 8 \
-                -command "Fix_Atoms $phase [list $numberList] Z $fix.z
-                Fix_Write
-                DisplayAllAtoms $phase"
+        button $fix.x -textvariable fixbtn_lbl(X) -width 8 \
+            -command "Fix_Atoms $phase [list $numberList] X"
+        button $fix.y -textvariable fixbtn_lbl(Y) -width 8 \
+            -command "Fix_Atoms $phase [list $numberList] Y"
+        button $fix.z -textvariable fixbtn_lbl(Z) -width 8 \
+            -command "Fix_Atoms $phase [list $numberList] Z"
         grid $fix.x -row 3 -column 0
         grid $fix.y -row 3 -column 1
@@ -2012 +2008 @@
 }
 
-#xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx x
-
-proc Fix_Initialize {numberList} {
-     set phaselist $::expmap(phaselist)
-     catch {unset ::fix_param}
-     foreach i $phaselist {
-             set ::fix_list(X,$i) ""
-             set ::fix_list(Y,$i) ""
-             set ::fix_list(Z,$i) ""
-
-             set temp [atom_constraint_read $i]
-             foreach j $temp {
-                     set atomnum [string trim [string range $j 2 3]]
-                     set param [string trim [string range $j 4 6]]
-                     set ::fix_param($i,$atomnum,$param) 1
-                     if {$param == "X"} {lappend ::fix_list(X,$i) $atomnum}
-                     if {$param == "Y"} {lappend ::fix_list(Y,$i) $atomnum}
-                     if {$param == "Z"} {lappend ::fix_list(Z,$i) $atomnum}
-             }
-     }
-    set ::fix_state_X [Fix_State $i $numberList X]
-    set ::fix_state_Y [Fix_State $i $numberList Y]
-    set ::fix_state_Z [Fix_State $i $numberList Z]
-}
-
+# test the fixed status of variable for several atoms
 proc Fix_State {phase numberList coord} {
-     set status_fixed "-1"
-     set status_unfixed "-1"
-     #puts "$coord before: $status_fixed $status_unfixed"
-     foreach i $numberList {
-         set temp [info exists ::fix_param($phase,$i,$coord)]
-         #puts "::fix_param($phase,$i,$coord) is variable present?: $temp"
-         if {$temp != 0} {set status_fixed 1}
-         if {$temp == 0} {set status_unfixed 1}
-     }
-     #puts "$coord after $status_fixed $status_unfixed"
-     if {$status_fixed == 1 && $status_unfixed != 1} {return "fixed"}
-     if {$status_fixed == 1 && $status_unfixed == 1} {return "mixed"}
-     if {$status_fixed != 1 && $status_unfixed == 1} {return "unfixed"}
-}
-
-proc Fix_Write {} {
-      incr ::expgui(changed)
-      #puts "Prepare to write [array names ::fix_Param]"
-      foreach j [array names ::fix_param] {
-             regexp {[0-9]+} $j  temp_phase
-             regexp {,[0-9]+} $j ans
-             set temp_atom [string range $ans 1 end]
-             regexp {[a-zA-Z]+} $j temp_param
-             if {$temp_param == "U"} {regexp {[a-zA-Z]+[0-9]+} $j temp_param}
-             set temp_entry [format "%1s %+2s%-4s" $temp_phase $temp_atom $temp_param]
-             lappend fix_list($temp_phase) $temp_entry
-     }
-     set phaselist $::expmap(phaselist)
-     foreach i $phaselist {
-             catch {atom_constraint_write $i $fix_list($i)}
-             catch  {RecordMacroEntry "catch {atom_constraint_write $i $fix_list($i)}" 0}
-             #puts $fix_list($i)
-     }
-}
-
-proc Fix_Atoms {phase numberList coord but} {
-#     puts "before  ::fix_state_$coord [set ::fix_state_$coord]"
-     #puts " before operationi: $::fix_list($coord,$phase)"
-     switch [set ::fix_state_$coord] {
-     "unfixed" {$but config -text "fixed"
-               set ::fix_state_$coord "fixed"
-               }
-     "fixed"   {$but config -text "unfixed"
-               set ::fix_state_$coord "unfixed"
-               }
-     "mixed"   {$but config -text "unfixed"
-               set ::fix_state_$coord "unfixed"
-               }
-     }
-     if {[set ::fix_state_$coord] == "fixed"} {
-        #puts "fixing atom number $numberList"
-        foreach i $numberList {
-                lappend ::fix_list($coord,$phase) $i
-                set ::fix_list($coord,$phase) [lsort -uniq -integer $::fix_list($coord,$phase)]
-                set ::fix_param($phase,$i,$coord) 1
+    set status_fixed 0
+    set status_unfixed 0
+    #puts "$coord before: $status_fixed $status_unfixed"
+    foreach i $numberList {
+        set temp [atom_constraint_get $phase $i $coord]
+        if {$temp == 0} {
+            set status_unfixed 1
+        } else {
+            set status_fixed 1
         }
-     }
-     if {[set ::fix_state_$coord] == "unfixed"} {
-        #puts "unfixing atoms $numberList"
-        foreach i $numberList {
-           set temp [lsearch $::fix_list($coord,$phase) $i]
-           if {$temp != -1} {
-              set ::fix_list($coord,$phase) [lreplace $::fix_list($coord,$phase) $temp $temp]
-              catch {unset ::fix_param($phase,$i,$coord)}
-           }
+        if {$status_fixed == 1 && $status_unfixed == 1} {
+            return "fix\nsome"
         }
-     }
-     #puts "after operation: $::fix_list($coord,$phase)"
+    }
+    #puts "$coord after $status_fixed $status_unfixed"
+    if {$status_fixed == 0} {return "fix"}
+    return "release"
+}
+
+# fix or release the selected atoms
+proc Fix_Atoms {phase numberList coord} {
+    if {$::fixbtn_lbl($coord) == "release"} {
+        set ::fixbtn_lbl($coord) "fix"
+        set mode 0
+    } else {
+        set ::fixbtn_lbl($coord) "release"
+        set mode 1
+    }
+    atom_constraint_set $phase $numberList $coord $mode
+    incr ::expgui(changed)
+    RecordMacroEntry "atom_constraint_set $phase [list $numberList] $coord $mode" 0
+    RecordMacroEntry "incr expgui(changed)" 0
+    DisplayAllAtoms $phase
 }
 

trunk/atomcons.tcl

@@ -11 +11 @@
     grid [NoteBook $expgui(consFrame).n -bd 2 -side bottom] -sticky news
     source [file join $expgui(scriptdir) profcons.tcl]
-    source [file join $expgui(scriptdir) distrest.tcl]
 }
 
@@ -21 +20 @@
     catch {$expgui(consFrame).n delete macro}
     catch {$expgui(consFrame).n delete profile}
-    catch {$expgui(consFrame).n delete distrest}
     set atom normal
     set mm disabled
@@ -47 +45 @@
             -createcmd "MakeProfileConstraintsPane" \
             -raisecmd "DisplayProfileConstraints"]    
-    set expcons(distmaster) [\
-            $expgui(consFrame).n insert end distrest -text "Distance Restraints" \
-            -state $atom \
-            -createcmd "" \
-            -raisecmd "DisplayDistanceRestraints"]
- 
+
     set page [$expgui(consFrame).n raise]
     # open the atom constraints page if no page is open
@@ -829 +822 @@
     DisplayAtomConstraints $mode
 }
+######################################################################
+# restraints codes
+######################################################################
+# this is used once to create the constraint page
+proc MakeRestraintsPane {} {
+    global expgui expcons expmap
+    # create the notebook
+    grid [NoteBook $expgui(restrFrame).n -bd 2 -side bottom] -sticky news
+    source [file join $expgui(scriptdir) distrest.tcl]
+    source [file join $expgui(scriptdir) chemrest.tcl]
+}
+
+# this is used to update the contents of the constraint page when displayed
+proc DisplayRestraintsPane {} {
+    global expgui expcons expmap
+    # create pages for each of the constraint "subpages"
+    catch {$expgui(restrFrame).n delete distrest}
+    catch {$expgui(restrFrame).n delete chemrest}
+    set atom normal
+    set mm disabled
+    if {[llength $expmap(phasetype)] == 0} {
+        set atom disabled
+    } elseif {[lindex $expmap(phasetype) 0] == 4} {
+        set mm normal
+        if {[llength $expmap(phasetype)] == 1} {
+            set atom disabled
+        }
+    }
+    set expcons(distmaster) [\
+            $expgui(restrFrame).n insert end distrest -text "Distance Restraints" \
+            -state $atom \
+            -createcmd "" \
+            -raisecmd "DisplayDistanceRestraints"]
+ 
+    set expcons(chemmaster) [\
+            $expgui(restrFrame).n insert end chemrest -text "Chemical Restraints" \
+            -state $atom \
+            -createcmd "" \
+            -raisecmd "DisplayChemRestraints"]
+ 
+    set page [$expgui(restrFrame).n raise]
+    # open the atom constraints page if no page is open
+    if {$page == ""} {
+        foreach page [$expgui(restrFrame).n pages] {
+            # loop to the first non-disabled page
+            if {[$expgui(restrFrame).n itemcget $page -state] == "normal"} {
+                $expgui(restrFrame).n raise $page
+                return
+            }
+        }
+    } else {
+        set pageupdate [$expgui(restrFrame).n itemcget $page -raisecmd]
+        catch $pageupdate
+    }
+}

trunk/distrest.tcl

@@ -36 +36 @@
 #SR_Build
 
+set ::sr_atom1_button 1
+set ::sr_atom2_button 1
+set ::sr_distance_button 1
+set ::sr_entryvar(choicenum) 0
+#    set ::sr_entryvar(softphase) "1"
+#    set ::sr_phaselist $::expmap(phaselist)
+set ::sr_entryvar(softatom1) "all"
+set ::sr_entryvar(softatom2) "all"
+set ::sr_phaselist $::expmap(phaselist)
+set ::sr_error 0
+set ::sr_bond_list ""
+set ::sr_dminvalue 0
+set ::sr_dmaxvalue 1000
+set ::sr_display_mode noedit
+set ::sr_key_list ""
+
 proc DisplayDistanceRestraints {args} {
     #puts DisplayDistanceRestraints
@@ -83 +99 @@
     set ::entrycmd(trace) 0
     set ::entryvar(distrestweight) [SoftConst weight]
-    RecordMacroEntry "set ::entryvar(distrestweight) [SoftConst weight]" 0
+    #RecordMacroEntry "set ::entryvar(distrestweight) [SoftConst weight]" 0
     set ::entrycmd(trace) 1
-    incr ::expgui(changed)
+    #incr ::expgui(changed)
 
     #Run Disagl Commands *****************************************************
@@ -104 +120 @@
 
 
-    foreach {top main side lbl} [MakeScrollTable $rightfr] {}
+    foreach {top main side lbl} [MakeScrollTable $rightfr 450 300] {}
     MouseWheelScrollTable $rightfr
     set atom1_state  1
@@ -724 +740 @@
     putontop $mrb
 }
-#************************************************************************
-#Procedure to Initialize variables ***************************************
-#*************************************************************************
-proc SR_Initialize {} {
-    set ::sr_atom1_button 1
-    set ::sr_atom2_button 1
-    set ::sr_distance_button 1
-    set ::sr_entryvar(choicenum) 0
-    #    set ::sr_entryvar(softphase) "1"
-    #    set ::sr_phaselist $::expmap(phaselist)
-    set ::sr_entryvar(softatom1) "all"
-    set ::sr_entryvar(softatom2) "all"
-    set ::sr_phaselist $::expmap(phaselist)
-    set ::sr_error 0
-    set ::sr_bond_list ""
-    set ::sr_dminvalue 0
-    set ::sr_dmaxvalue 1000
-    set ::sr_display_mode noedit
-    set ::sr_key_list ""
-    #SR_Rest_Only
-}
 
 # load restraints w/o distances
@@ -783 +778 @@
     donewait
 }
-
-#expload TEST3.EXP
-#mapexp
-SR_Initialize
-#SR_Read_Distances test2.disagl
-#SR_Load_Restraints
-#SR_Main_Editor
-#SR_Load_Restraints
-
-

trunk/expgui

@@ -68 +68 @@
 catch {if $env(DEBUG) {set expgui(debug) 1}}
 #set expgui(debug) 1
-
+set expgui(HistSelectList) {}
 # location for web pages, if not found locally
 set expgui(website) 11bm.xor.aps.anl.gov/expguidoc/
@@ -159 +159 @@
 source [file join $expgui(scriptdir) disagledit.tcl]
 source [file join $expgui(scriptdir) Geo_Viewer.tcl]
+# setup Anomalous Dispersion Coefficent Editor
+source [file join $expgui(scriptdir) anomal.tcl]
 #---------------------------------------------------------------------------
 # override options with locally defined values
@@ -1337 +1339 @@
     # is this fixed?
     set param [string toupper $var]
-    if {[array name ::fix_param "$phase,$atom,$param"] != ""} {
-        return [format "%9.5fF" [atominfo $phase $atom $var]]
+    if {[atom_constraint_get $phase $atom $param]} {
+        return [format "%9.5ff" [atominfo $phase $atom $var]]
     }
     # is this atom in a rigid body?
@@ -1635 +1637 @@
             -yscrollcommand "$frm.y set" \
             ] -row 2 -column 0 -sticky news
-    lappend expgui(HistSelectList) $frm
+    if {[lsearch $expgui(HistSelectList) $frm] < 0} {
+        lappend expgui(HistSelectList) $frm
+    }
     grid [scrollbar $frm.x -orient horizontal \
             -command "move2boxesX \" $frm.title $frm.lbox \" " 
@@ -1659 +1663 @@
     }
     foreach lbox $expgui(HistSelectList) {
+        if {! [winfo exists $lbox]} continue
         $lbox.title delete 0 end
         $lbox.lbox delete 0 end
@@ -1721 +1726 @@
     # title field needs to match longest title
     foreach lbox $expgui(HistSelectList) {
+        if {! [winfo exists $lbox]} continue
         $lbox.title insert end [format "%2s %s %4s %8s  %-67s" \
                 "h#" \
@@ -1756 +1762 @@
         }
         foreach lbox $expgui(HistSelectList) {
+            if {! [winfo exists $lbox]} continue
             $lbox.lbox insert end [format "%2d  %s %4d %8s  %-67s" \
                     $h \
@@ -1793 +1800 @@
             } else {
                 $c configure -state normal
-            }  
+            }
         }
     }
@@ -1815 +1822 @@
         set expgui(backtermlbl) ""
         set expgui(backtypelbl) ""
-        set expgui(abstypelbl) "" 
+        set expgui(abstypelbl) ""
         foreach var {bref bdamp absref absdamp} {
             set entrycmd($var) ""
@@ -1821 +1828 @@
         }
         $expgui(histFrame).top.txt config -text "No Selected Histograms"
-        grid $expgui(histFrame).top -column 1 -row 0 -sticky nsew       
+        grid $expgui(histFrame).top -column 1 -row 0 -sticky nsew
         set expgui(bkglbl) ""
         set expgui(abslbl) ""
@@ -1832 +1839 @@
         set expgui(backtermlbl) ""
         set expgui(backtypelbl) ""
-        set expgui(abstypelbl) "" 
+        set expgui(abstypelbl) ""
         foreach var {bref bdamp absref absdamp} {
             set entrycmd($var) "histinfo [list $histlist] $var"
             set entryvar($var) [histinfo [lindex $histlist 0] $var]
         }
+        $expgui(histFrame).bb.anom config -state disabled
     } else {
         set hist $histlist
@@ -1869 +1877 @@
             set expgui(abstypelbl) "  Model #$abstype, value: [histinfo $hist abscor1]"
         }
+        $expgui(histFrame).bb.anom config -state normal
     }
     # Top box
@@ -3328 +3337 @@
             DisplayProfile \
             1  expgui5.html ""}
-    {consFrame    "Re/Constraints" \
+    {consFrame    "Constraints" \
             "source [file join $expgui(scriptdir) atomcons.tcl]; MakeConstraintsPane" \
             DisplayConstraintsPane \
+            0  expgui6.html ""}
+    {restrFrame    "Restraints" \
+            "source [file join $expgui(scriptdir) atomcons.tcl]; MakeRestraintsPane" \
+            DisplayRestraintsPane \
             0  expgui6.html ""}
     {rbFrame   "Rigid Body" \
@@ -3893 +3906 @@
             -command SetHistUseFlags
     grid $expgui(histFrame).bb.use -column 2 -row 1
+    button $expgui(histFrame).bb.anom -text "Edit\n\u0394f' and \u0394f\""\
+            -command Edit_Anomalous
+    grid $expgui(histFrame).bb.anom -column 3 -row 1
 
     # BACKGROUND information.

trunk/gsascmds.tcl

@@ -2427 +2427 @@
 # creates a table that is scrollable in both x and y, use ResizeScrollTable
 # to set sizes after gridding the widgets
-proc MakeScrollTable {box} {
+proc MakeScrollTable {box {width 200} {height 200}} {
     proc sync2boxes {cmd master slave scroll args} {
         $slave $cmd moveto [lindex [$master $cmd] 0]
@@ -2446 +2446 @@
             -yscrollcommand "sync2boxes yview $box.can $box.side $box.yscroll" \
             -xscrollcommand "sync2boxes xview $box.can $box.top $box.scroll" \
-            -width 200 -height 200 -bg lightgrey] -sticky news -row 1 -column 1
+            -width $width -height $height -bg lightgrey] -sticky news -row 1 -column 1
     grid [set sxbox [scrollbar $box.scroll -orient horizontal \
                          -command "move2boxes xview $box.can $box.top"]] \

trunk/rbimport_zmatrix.tcl

@@ -28 +28 @@
 
      grid [button $zmat.con.but -text "Load Z-Matrix" -width 22 -command "RB_Zmat $zmat.display"] -row 2 -column 1
-     grid [button $zmat.save.but2 -text "Convert to Cartesian \n Coordnates" -width 17 -command "RB_Zmat_Convert"] -row 2 -column 1 -padx 5
+     grid [button $zmat.save.but2 -text "Continue" -width 17 -command "RB_Zmat_Convert"] -row 2 -column 1 -padx 5
           $zmat.save.but2 config -state disable
      grid [button $zmat.save.but3 -text "Abort" -width 17 -command "destroy .zmatrix"] -row 2 -column 2 -padx 5 -sticky ns

trunk/readexp.tcl

@@ -2243 +2243 @@
 }
 
-#  read fixed constraints
-
+#  read fixed constraints for a phase
 proc atom_constraint_read {phase} {
-    set fix_list ""
+    set fixlist ""
     foreach k {1 2 3 4 5 6 7 8 9} {
         set key [format "LEQV HOLD%1d%2d" $phase $k]
@@ -2252 +2251 @@
         foreach j {2 10 18 26 34 42 50 58} {
             set fix_param [string range $line $j [expr $j+7]]
-            if {[string trim $fix_param] == ""} {return $fix_list}
-            lappend fix_list $fix_param
-        }
-    }
+            if {[string trim $fix_param] == ""} {return $fixlist}
+            lappend fixlist $fix_param
+        }
+    }
+    return $fixlist
 }
 
@@ -2271 +2271 @@
 }
 
-proc atom_constraint_write {phase fix_list} {
+# returns 1 if the specified variable is fixed
+proc atom_constraint_get {phase atom type} {
+    if {[array names ::fix_param "$phase,$atom,$type"] == ""} {
+        return 0
+    }
+    return 1
+}
+
+proc atom_constraint_set {phase atomlist type mode} {
+    foreach atom $atomlist {
+        set key "$phase,$atom,$type"
+        if {$mode} {
+            set ::fix_param($key) 1
+        } else {
+            array unset ::fix_param $key
+        }
+    } 
+    set fixlist {}
+    foreach key [array names ::fix_param "$phase,*"] {
+        foreach {j atom parm} [split $key ","] {}
+        lappend fixlist \
+            [format "%1s %+2s%-4s" $phase $atom $parm]
+    }
     foreach key [array names ::exparray "LEQV HOLD$phase*"] {
         delexp $key
@@ -2278 +2300 @@
     set j 1
     set line ""
-    foreach fix $fix_list {
+    foreach fix $fixlist {
         incr k
         append line $fix
@@ -2327 +2349 @@
 #              phase-list, histogram-list, multiplier
 # Note that phase-list and/or histogram-list can be ALL
+#
+#  type action
+#  -----------
+#  absorbX get number         returns a list of constraints for term X=1 or 2
+#   returns a the number of constraints for number = 0
+#   returns a list of lists {{hist mult} {hist mult} ...}
+
+#  absorbX set number value   replaces a list of constraints 
+#      number corresponds to a specific constraint see "absorbX get 0"
+#      value is a list of lists {{hist mult} {hist mult} ...}
+#  absorbX add number value   inserts a new list of constraints 
+#                               (number is ignored)
+#  absorbX  delete number      deletes a set of constraint entries and renumbers
+# note that hist can be:
+#      a histogram number (such as 2) or
+#      range of histograms (such as 1:10 or 11:99, etc.) or
+#      the string "ALL"
 
 proc constrinfo {type action number "value {}"} {
@@ -2592 +2631 @@
                     # this line is not needed
                     if {$j % 3 == 1} {
-                        delexp %key
+                        delexp $key
                     }
                     continue
@@ -2710 +2749 @@
             return $clist
         }
+        absorb*-delete {
+            regsub absorb $type {} term
+            set key "LEQV ABS$term   "
+            if {! [existsexp $key]} {return 0}
+            # current number of constraints
+            set nterm [string trim [string range [readexp $key] 0 5]]
+            if {$nterm == ""} {return 0}
+            # does the entry exist?
+            if {$nterm < $number} {
+                puts "deleted!"
+                return $nterm
+            }
+            for {set target $number} {$target < $nterm} {incr target} {
+                set source [expr {$target + 1}]
+                set recs [GetAbsCount $term $source]
+                SetAbsCount $term $target [expr {3*$recs}]
+                validint source 2
+                validint target 2
+                for {set i 1} {$i <= $recs} {incr i} {
+                    set keyin "LEQV ABS${term}${source}$i"
+                    set keyout "LEQV ABS${term}${target}$i"
+                    set ::exparray($keyout) $::exparray($keyin)
+                }
+            }
+            SetAbsCount $term $nterm 0
+            # delete the last entry
+            validint nterm 2
+            foreach i {1 2 3 4 5 6 7 8 9} {
+                set key "LEQV ABS${term}${nterm}$i"
+                delexp $key
+            }
+            # decrease the count by one
+            set nterm [expr {[string trim $nterm] - 1}]
+            if {$nterm == 0} {
+                delexp "LEQV ABS$term   "
+            } else {
+                validint nterm 5
+                setexp "LEQV ABS$term   " $nterm 1 5                    
+            }
+            return [string trim $nterm]
+
+            if {$term < 10} {
+                set term " $term"
+            }
+            set key "LEQV PF$term   "
+            # return nothing if no term exists
+            if {![existsexp $key]} {return 0}
+
+            # number of constraint terms
+            set nterms [string trim [string range [readexp ${key}] 0 4] ]
+            # don't delete a non-existing entry
+            if {$number > $nterms} {return 0}
+            set val [expr {$nterms - 1}]
+            validint val 5
+            setexp $key $val 1 5
+            for {set i1 $number} {$i1 < $nterms} {incr i1} {
+                set i2 [expr {1 + $i1}]
+                # move the contents of constraint #i2 -> i1
+                if {$i1 > 9} {
+                    set k1 [expr {($i1+1)/10}]
+                    set l1 $i1
+                } else {
+                    set k1 " "
+                    set l1 " $i1"
+                }
+                set key1 "LEQV PF$term  $k1"
+                # number of constraint lines for #i1
+                set n1 [string trim [string range [readexp ${key1}] \
+                        [expr {($i1%10)*5}] [expr {4+(($i1%10)*5)}]] ]
+                if {$i2 > 9} {
+                    set k2 [expr {($i2+1)/10}]
+                    set l2 $i2
+                } else {
+                    set k2 " "
+                    set l2 " $i2"
+                }
+                set key2 "LEQV PF$term  $k2"
+                # number of constraint lines for #i2
+                set n2 [string trim [string range [readexp ${key2}] \
+                        [expr {($i2%10)*5}] [expr {4+(($i2%10)*5)}]] ]
+                set val $n2
+                validint val 5
+                # move the # of terms
+                setexp $key1 $val [expr {1+(($i1%10)*5)}] 5
+                # move the terms
+                for {set j 1} {$j <= $n2} {incr j 1} {
+                    set key "LEQV PF${term}${l1}$j"
+                    makeexprec $key
+                    setexp $key [readexp "LEQV PF${term}${l2}$j"] 1 68
+                }
+                # delete any remaining lines
+                for {set j [expr {$n2+1}]} {$j <= $n1} {incr j 1} {
+                    delexp "LEQV PF${term}${l1}$j"
+                }
+            }
+
+            # clear the last term
+            if {$nterms > 9} {
+                set i [expr {($nterms+1)/10}]
+            } else {
+                set i " "
+            }
+            set key "LEQV PF$term  $i"
+            set cb [expr {($nterms%10)*5}]
+            set ce [expr {4+(($nterms%10)*5)}]
+            set n2 [string trim [string range [readexp ${key}] $cb $ce] ]
+            incr cb
+            setexp $key "     " $cb 5
+            # delete any remaining lines
+            for {set j 1} {$j <= $n2} {incr j 1} {
+                delexp "LEQV PF${term}${nterms}$j"
+            }
+        }
+        absorb*-set {
+            regsub absorb $type {} term
+            if {$number < 1} return   
+            # delete old records
+            set l [GetAbsCount $term $number]
+            set num $number
+            validint num 2
+            for {set i 1} {$i <= $l} {incr i} {
+                delexp "LEQV ABS${term}${num}$i"
+            }
+            # record the new number of records
+            SetAbsCount $term $number [llength $value]
+            # save the new records
+            set i 1
+            set offh 2
+            set offm 14
+            foreach set $value {
+                set hist [string trim [lindex $set 0]]
+                set mult [string trim [lindex $set 1]]
+                validreal mult 8 4
+                set key "LEQV ABS${term}${num}$i"
+                if {$offh == 2} {
+                    makeexprec $key
+                }
+                setexp $key $hist [expr {$offh+1}] 11
+                setexp $key $mult [expr {$offm+1}] 8
+                incr offh 21
+                incr offm 21
+                if {$offm > 67} {
+                    incr i
+                    set offh 2
+                    set offm 14
+                }
+            }
+            return
+        }
+        absorb*-add {
+            regsub absorb $type {} term
+            set key "LEQV ABS$term   "
+            if {! [existsexp $key]} {makeexprec $key}
+            # current number of constraints
+            set nterm [string trim [string range [readexp $key] 0 5]]
+            if {$nterm == ""} {set nterm 0}
+            if {$nterm >= 99} {
+                return $nterm
+            }
+            incr nterm
+            validint nterm 5
+            setexp $key $nterm 1 5
+            constrinfo $type set [string trim $nterm] $value
+            return [string trim $nterm]
+        }
+        absorb*-get {
+            regsub absorb $type {} term
+            # no constraints, return blank
+            set key "LEQV ABS$term   "
+            if {! [existsexp $key]} {return ""}
+            # requesting number of constraints
+            if {$number == 0} {
+                set l [string trim [string range [readexp ${key}] 0 5]]
+                if {$l == ""} {return 0}
+                return $l
+            }
+            # 
+            if {$number > 9} {
+                set num $number
+                set i [expr {($number+1)/10}]
+                set off [expr {5*($number % 10)}]
+                set key "LEQV ABS$term  $i"
+            } else {
+                set num " $number"
+                set i " "
+                set off [expr {5*($number % 10)}]
+            }
+            set off1 [expr {$off + 5}]
+            set l [string trim [string range [readexp ${key}] $off $off1]]
+            if {$l == ""} {return {}}
+            # now look up those records
+            set res {}
+            for {set i 1} {$i <= $l} {incr i} {
+                set key "LEQV ABS${term}${num}$i"
+                for {set j 0} {$j < 3} {incr j} {
+                    set off [expr {2 + 21*$j}]
+                    set off1 [expr {$off + 11}]
+                    set hist [string trim [string range [readexp ${key}] $off $off1]]
+                    set off [expr {14 + 21*$j}]
+                    set off1 [expr {$off + 7}]
+                    set mult [string trim [string range [readexp ${key}] $off $off1]]
+                    if {$mult == ""} break
+                    lappend res [list $hist $mult]
+                }
+            }
+            return $res
+        }
         default {
             set msg "Unsupported constrinfo access: type=$type action=$action"
@@ -2716 +2962 @@
 
     }
+}
+proc GetAbsCount {term number} {
+    if {$number > 9} {
+        set num $number
+        set off [expr {5*($number % 10)}]
+        set i [expr {($number+1)/10}]
+        set key "LEQV ABS$term  $i"
+    } else {
+        set num " $number"
+        set off [expr {5*($number % 10)}]
+        set key "LEQV ABS$term   "
+    }
+    set off1 [expr {$off + 5}]
+    set l [string trim [string range [readexp ${key}] $off $off1]]
+    if {$l == ""} {set l 0}
+    return $l
+}
+proc SetAbsCount {term number len} {
+    if {$number > 9} {
+        set num $number
+        set off [expr {1 + 5*($number % 10)}]
+        set i [expr {($number+1)/10}]
+        set key "LEQV ABS$term  $i"
+    } else {
+        set num " $number"
+        set off [expr {1 + 5*($number % 10)}]
+        set key "LEQV ABS$term   "
+    }
+    set l [expr {($len + 2)/3}]
+    set val $l
+    validint val 5
+    setexp $key $val $off 5
 }
 
@@ -3311 +3589 @@
         default {
             set msg "Unsupported phaseinfo access: parm=$parm action=$action"
+            tk_dialog .badexp "Error in readexp" $msg error 0 Exit 
+        }
+    return 1
+    }
+}
+
+# read/edit chemical restraint info
+#  parm:
+#    weight -- histogram weight (factr) * 
+#    restraintlist -- list of restraints *
+#  action: get (default) or set
+#  value: used only with set
+#      value is a list of constraints
+#      each constrain contains {sum esd cons1 cons2...}
+#      each consN contains {phase atomnum multiplier}
+#  * =>  read+write supported 
+# Examples:
+#
+#ChemConst restraintlist set { {10 1.1 {1 1 2} {2 2 3}} {0 1 {1 1 1} {1 2 -2}} }
+#
+#ChemConst restraintlist get
+#{10.00000 1.10000 {1 1 2.00000} {2 2 3.00000}} {0.00000 1.00000 {1 1 1.00000} {1 2 -2.00000}}
+# constraint one 2*(1:1) + 3*(2:2) = 10(1.1)
+# constraint two 1*(1:1) - 2*(1:2) = 0(1)
+#   where (1:2) is the total number of atoms (multiplicity*occupancy) for atom 2 in phase 1
+
+proc ChemConst {parm "action get" "value {}"} {
+    set HST {}
+    # look for CMP record
+    set n 0
+    for {set i 0} {$i < $::expmap(nhst)} {incr i} {
+        set ihist [expr {$i + 1}]
+        if {[expr {$i % 12}] == 0} {
+            incr n
+            set line [readexp " EXPR  HTYP$n"]
+            if {$line == ""} {
+                set msg "No HTYP$n entry for Histogram $ihist. This is an invalid .EXP file"
+                tk_dialog .badexp "Error in readexp" $msg error 0 Exit 
+            }
+            set j 0
+        } else {
+            incr j
+        }
+        if {[string range $line [expr 2+5*$j] [expr 5*($j+1)]] == "CMP "} {
+            set HST $ihist
+        }
+    }
+    if {$HST <=9} {
+        set key "HST  $HST"
+    } else {
+        set key "HST $HST"
+    }
+    if {$HST == "" && $action == "set"} {
+        # no CMP found need to add the soft constr. histogram
+        # increment number of histograms
+        set hst [string trim [string range [readexp { EXPR  NHST }] 0 4]]
+        incr hst
+        set HST $hst
+        if ![validint hst 5] {return 0}
+        setexp  { EXPR  NHST } $hst 1 5
+        # add to EXPR HTYPx rec, creating if needed 
+        set n [expr { 1+ (($HST - 1) / 12) }]
+        set key " EXPR  HTYP$n"
+        if {[array names ::exparray $key] == ""} {
+            makeexprec $key
+        }
+        setexp $key "CMP " [expr 3 + 5*(($HST-1) % 12)] 5
+        # create other HST  xx recs
+        if {$HST <=9} {
+            set key "HST  $HST"
+        } else {
+            set key "HST $HST"
+        }
+        makeexprec "$key  HNAM"
+        setexp "$key  HNAM" "Chemical composition restraints" 3 31
+        makeexprec "$key FACTR"
+#       makeexprec "$key NBNDS"
+        makeexprec "$key NCMPS"
+        mapexp
+    } elseif {$HST == ""} {
+        if $::expgui(debug) {puts "no restraints"}
+        return "1"
+    }
+
+    switch -glob ${parm}-$action {
+        weight-get {
+            return [string trim [string range [readexp "$key FACTR"] 0 14]]
+        }
+        weight-set {
+            # update FACTR
+            if ![validreal value 15 6] {return 0}
+            setexp "$key FACTR" $value 1 15
+        }
+        restraintlist-get {
+            set ncons [string trim [string range [readexp "$key NCMPS"] 0 4]]
+            set conslist {}
+            for {set i 1} {$i <= $ncons} {incr i} {
+                set const {}
+                set line [readexp "${key} CM$i  "]
+                # number of terms
+                set nterm [string trim [string range $line 0 4]]
+                if {$nterm == ""} {set nterm 0}
+                # chemical sum and esd
+                lappend const [string trim [string range $line 5 14]]
+                lappend const [string trim [string range $line 15 24]]
+                for {set j 1} {$j <= $nterm} {incr j} {
+                    set n [expr {($j + 2)/3}]
+                    set o1 [expr {20*(($j-1)%3)}]
+                    set o2 [expr {19 + 20*(($j-1)%3)}]
+                    validint n 2
+                    if {$o1 == 0} {
+                        set line [readexp "${key} CM${i}${n}"]
+                    }
+                    set frag [string range $line $o1 $o2]                    
+                    lappend const [list \
+                                       [string trim [string range $frag 0 4]] \
+                                       [string trim [string range $frag 5 9]] \
+                                       [string trim [string range $frag 10 19]] \
+                                   ]
+                }
+                lappend conslist $const
+            }
+            return $conslist
+        }
+        restraintlist-set {
+            set num [llength $value]
+            if ![validint num 5] {return 0}
+            setexp "$key NCMPS" $num 1 5
+            # delete all old records
+            foreach i [array names ::exparray "${key} CM*"] {
+                unset ::exparray($i)
+            }
+            set i 0
+            foreach cons $value {
+                incr i
+                set sum [lindex $cons 0]
+                set esd [lindex $cons 1]
+                set terms [lrange $cons 2 end]
+                set nterms [llength $terms]
+                validint nterms 5
+                validreal sum 10 5
+                validreal esd 10 5
+                makeexprec "${key} CM$i  " 
+                setexp "${key} CM$i  " "${nterms}${sum}${esd}" 1 25
+                set j 0
+                set str {}
+                foreach term $terms {
+                    incr j
+                    set n [expr {($j + 2)/3}]
+                    if {$n > 99} break
+                    validint n 2
+                    foreach {phase atom mult} $term {}
+                    validint phase 5
+                    validint atom 5
+                    validreal mult 10 5
+                    append str "${phase}${atom}${mult}"
+                    if {[expr {$j%3}] == 0} {
+                        #puts [readexp "${key} CM${i}${n}"]
+                        makeexprec "${key} CM${i}${n}"
+                        setexp "${key} CM${i}${n}" $str 1 60
+                        set str {}
+                    }
+                }
+                if {[string length $str] > 0} {
+                    makeexprec "${key} CM${i}${n}"
+                    setexp "${key} CM${i}${n}" $str 1 60
+                }
+            }
+        }
+        default {
+            set msg "Unsupported phaseinfo access: parm=$parm action=$action"
+            puts $msg
             tk_dialog .badexp "Error in readexp" $msg error 0 Exit 
         }
@@ -4287 +4737 @@
 }
 
+# return a list of defined Fourier maps
+proc listFourier {} {
+    set l {}
+    foreach i {1 2 3 4 5 6 7 8 9} {
+        if {[existsexp "  FOUR CDAT$i"]} {
+            lappend l $i
+        }
+    }
+    return $l
+}
+
+# read a Fourier map entry
+# returns five values:
+#   0: type of map (DELF,FCLC,FOBS,NFDF,PTSN,DPTS)
+#   1: section (X,Y or Z)
+#   2: phase (1-9)
+#   3: DMIN (usually 0.0)
+#   4: DMAX (usually 999.99)
+proc readFourier {num} {
+    set key "  FOUR CDAT$num"
+    if {![existsexp $key]} {
+        return {}
+    }
+    set vals {}
+    # 0: type of map (DELF,FCLC,FOBS,NFDF,PTSN,DPTS)
+    lappend vals [string trim [string range [readexp $key] 2 6]]
+    # 1: section (X,Y or Z)
+    lappend vals [string trim [string range [readexp $key] 7 8]]
+    # 2: phase (1-9)
+    lappend vals [string trim [string range [readexp $key] 8 13]]
+    # 3: DMIN (usually 0.0)
+    lappend vals [string trim [string range [readexp $key] 18 25]]
+    # 4: DMAX (usually 999.99)
+    lappend vals [string trim [string range [readexp $key] 30 37]]
+    return $vals
+}
+
+# add a new Fourier map computation type
+#   arguments:
+#      phase: (1-9)
+#      type: type of map (DELF,FCLC,FOBS,NFDF,PTSN,DPTS) - default DELF
+#      section: (X,Y or Z) - default Z
+#   returns the number of the map that is added
+proc addFourier {phase {type "DELF"} {section "Z"}} {
+    set num {}
+    foreach i {1 2 3 4 5 6 7 8 9} {
+        set key "  FOUR CDAT$i"
+        if {! [existsexp "  FOUR CDAT$i"]} {
+            set num $i
+            break
+        }
+    }
+    if {$num == ""} {return {}}
+    set key "  FOUR CDAT$num"
+    makeexprec $key
+    setexp $key $type 3 4
+    setexp $key $section 8 1
+    validint phase 5
+    setexp $key $phase 9 5
+    setexp $key "NOPR   0.00      999.99" 15 23
+    return $num
+}
+
+# read/set a Fourier computation value
+# use: Fourierinfo num parm 
+#  or: Fourierinfo num parm set value
+#
+#  num is the Fourier entry
+#  parm is one of the following
+#     type    -- type of map (DELF,FCLC,FOBS,NFDF,PTSN,DPTS)
+#     section -- last running map direction (X,Y or Z)
+#     phase   -- phase (1-9)
+#     dmin    -- d-space for highest order reflection to use (usually 0.0)
+#     dmax    -- d-space for lowest order reflection to use (usually 999.99)
+# all parameters may be read or set
+proc Fourierinfo {num parm "action get" "value {}"} {
+    set key "  FOUR CDAT$num"
+    if {![existsexp $key]} {
+        return {}
+    }
+    switch -glob ${parm}-$action {
+        type-get {
+            # type of map (DELF,FCLC,FOBS,NFDF,PTSN,DPTS)
+            return [string trim [string range [readexp $key] 2 6]]
+        }
+        type-set {
+            set found 0
+            foreach val {DELF FCLC FOBS NFDF PTSN DPTS} {
+                if {$val == $value} {
+                    set found 1
+                    break
+                }
+            }
+            if $found {
+                setexp $key $value 3 4
+            }
+        }
+        section-get {
+            # section (X,Y or Z)
+            return [string range [readexp $key] 7 8]
+        }
+        section-set {
+            set found 0
+            foreach val {X Y Z} {
+                if {$val == $value} {
+                    set found 1
+                    break
+                }
+            }
+            if $found {
+                setexp $key $value 8 1
+            }
+        }
+        phase-get {
+            # phase (1-9)
+            return [string trim [string range [readexp $key] 8 13]]
+        }
+        phase-set {
+            validint value 5
+            setexp $key $value 9 5
+        }
+        dmin-get {
+            # DMIN (usually 0.0)
+            return [string trim [string range [readexp $key] 18 25]]
+        }
+        dmin-set {
+            validreal value 7 2
+            setexp $key $value 19 7
+        }
+        dmax-get {
+            # DMAX (usually 999.99)
+            return [string trim [string range [readexp $key] 30 37]]
+        }
+        dmax-set {
+            validreal value 7 2
+            setexp $key $value 31 7
+        }
+        default {
+            set msg "Unsupported Fourierinfo access: parm=$parm action=$action"
+            puts $msg
+            tk_dialog .badexp "Error in readexp" $msg error 0 Exit 
+        }
+    }
+}
+
+# set histograms used in Fourier computation
+#  use:
+#     FourierHists $phase 
+#     FourierHists $phase set {4 3 2 1}
+# returns a list of histograms to be used to compute that phase's Fourier map
+# or sets a list of histograms to be used to compute that phase's Fourier map
+#
+# Note that the histograms are loaded in the order specified with reflections in
+# the last histogram overwriting those in earlier ones, where a reflection
+# occurs in more than one place
+proc FourierHists {phase "action get" "value {}"} {
+    # note that in theory one can have more than one CRSm  FMHSTn record
+    # if more than 22 histograms are used but we will ignore this
+    set key "CRS$phase  FMHST1"
+    if {![existsexp $key]} {
+        makeexprec $key
+    }
+    if {$action == "get"} {
+        return [string trim [readexp $key]]
+    } else {
+        set hlist {}
+        foreach hist $value {
+            validint hist 3
+            append hlist $hist
+        }
+        setexp $key $hlist 0 67
+    }
+}
+# get the Fourier map computation step and limits
+# returns 4 lists:
+#   {stepx stepy stepz} : step size in Angstroms
+#   {xmin xmax} : min and max x in fractional coordinates
+#   {ymin ymax} : min and max y in fractional coordinates
+#   {zmin zmax} : min and max z in fractional coordinates
+proc getFourierLimits {phase} {
+    set key "CRS$phase  FMPCTL"
+    if {![existsexp $key]} {
+        setFourierLimits $phase
+    }
+    set i 0
+    set line [readexp $key]
+    foreach v {x y z} cell {a b c} {
+        set cell_$v [phaseinfo $phase $cell]
+    }
+    foreach typ {step min max} {
+        foreach v {x y z} {
+            set val [string trim [string range $line $i [expr $i+5]]]
+            if {$val == ""} {set val 0}
+            set ${typ}_${v} $val
+            incr i 5
+        }            
+    }
+    set steps {}
+    foreach v {x y z} {
+        set range_$v {}
+        lappend steps [expr {[set cell_$v] / [set step_$v]}]
+        lappend range_$v [expr {[set min_$v] * 1. / [set step_$v] }]
+        lappend range_$v [expr {[set max_$v] * 1. / [set step_$v] }]
+    }
+    return [list $steps $range_x $range_y $range_z]
+}
+
+# set the Fourier map computation step and limits
+#   Asteps contains {stepx stepy stepz} : step size in Angstroms
+#   range_x contains {xmin xmax} : min and max x in fractional coordinates
+#   range_y contains {ymin ymax} : min and max y in fractional coordinates
+#   range_z contains {zmin zmax} : min and max z in fractional coordinates
+proc setFourierLimits {phase \
+                           {Asteps {.2 .2 .2}} \
+                           {range_x {0 1}} \
+                           {range_y {0 1}} \
+                           {range_z {0 1}} } {
+    set key "CRS$phase  FMPCTL"
+    if {![existsexp $key]} {
+        makeexprec $key
+    }
+    set i 1
+    # steps across map
+    foreach v {x y z} cell {a b c} As $Asteps {
+        set s [expr {1 + int([phaseinfo $phase $cell] / $As)}]
+        set s [expr {$s + ($s % 2)}]
+        set step_$v $s
+        lappend steps [set step_$v]
+        validint s 5
+        setexp $key $s $i 5
+        incr i 5
+    }
+    # x,y,z min in steps
+    foreach v {x y z} {
+        foreach {min max} [set range_$v] {}
+        set s [expr {int($min * [set step_$v]-.5)}]
+        validint s 5
+        setexp $key $s $i 5
+        incr i 5
+    }
+    # x,y,z max in steps
+    foreach v {x y z} {
+        foreach {min max} [set range_$v] {}
+        set s [expr {int($max * [set step_$v]+.5)}]
+        validint s 5
+        setexp $key $s $i 5
+        incr i 5
+    }
+}

trunk/rigid.tcl

@@ -75 +75 @@
 #          ::rb_firstatom                             contains first atom on active rigid body.  Must be gobal for variable has trace.
 #$         ::rb_phase                                 phase for active map
+#          ::rb(phase,bodnum,mapnum,x)                origin x coord
+#          ::rb(phase,bodnum,mapnum,y)                origin y coord
+#          ::rb(phase,bodnum,mapnum,z)                origin z coord
+#          ::rb(phase,bodnum,mapnum,e1)               euler angle 1
+#          ::rb(phase,bodnum,mapnum,e2)               euler angle 2
+#          ::rb(phase,bodnum,mapnum,e3)               euler angle 3
+
 
 # debug code to load test files when run as an independent script
@@ -109 +116 @@
     if {$::rbtypelist == ""} {
         MyMessageBox -parent . -title "Installation error" -icon warning \
-            -message "No rigid body import routines were found.\nSomething is wrong with the EXPGUI installation" 
+            -message "No rigid body import routines were found.\nSomething is wrong with the EXPGUI installation"
         set ::rbtypelist " "
     }
@@ -188 +195 @@
      set ::rb_map_positionvars($phase,$bodnum,$mapnum) [lindex $rb_map 3]
      set ::rb_map_damping($phase,$bodnum,$mapnum) [lindex $rb_map 4]
+
+     set ::rb_damp_origin [lindex $::rb_map_damping($phase,$bodnum,$mapnum) 6]
+     set ::rb_damp_euler [lindex $::rb_map_damping($phase,$bodnum,$mapnum) 0]
+
      set ::rb_map_tls($phase,$bodnum,$mapnum) [lindex $rb_map 5]
      set ::rb_map_tls_var($phase,$bodnum,$mapnum) [lindex $rb_map 6]
      set ::rb_map_tls_damp($phase,$bodnum,$mapnum) [lindex $rb_map 7]
+     
+     set ::rb_damp_t [lindex $::rb_map_tls_damp($phase,$bodnum,$mapnum) 0]
+     set ::rb_damp_l [lindex $::rb_map_tls_damp($phase,$bodnum,$mapnum) 1]
+     set ::rb_damp_s [lindex $::rb_map_tls_damp($phase,$bodnum,$mapnum) 2]
 }
 
@@ -454 +469 @@
      button $con.rb_vmatrix -text "Edit Matrix" -command "RB_Edit_Matrix $bodnum" -width 18
      grid   $con.rb_vmatrix -row 4 -column 1 -padx 5 -pady 5
-     grid [button $con.refine -text "Refinement \n Flags" -command "RB_Refine_Con" -width 18 ] -row 5 -column 1
+     grid [button $con.refine -text "Refinement \n Controls" -command "RB_Refine_Con" -width 18 ] -row 5 -column 1
 
      # create header for mapping data
@@ -466 +481 @@
      grid [label $main.rb_y   -text "y"] -row 1 -column 4
      grid [label $main.rb_z   -text "z"] -row 1 -column 5
-     grid [label $main.rb_euler_x -text "x"] -row 1 -column 6
-     grid [label $main.rb_euler_y -text "y"] -row 1 -column 7
-     grid [label $main.rb_euler_z -text "z"] -row 1 -column 8
+     grid [label $main.rb_euler_x -text "R1"] -row 1 -column 6
+     grid [label $main.rb_euler_y -text "R2"] -row 1 -column 7
+     grid [label $main.rb_euler_z -text "R3"] -row 1 -column 8
      set col 11
      for {set coordnum 1} {$coordnum <= $::rb_coord_num($bodnum,1)} {incr coordnum} {
@@ -1744 +1759 @@
 
 #                         puts $main
-                         grid [button $main.cfefx($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.cfefx($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,x) -width 5] -row $row -column 4
-                         grid [button $main.cfefy($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.cfefy($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,y) -width 5]  -row $row -column 5
-                         grid [button $main.cfefz($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.cfefz($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,z) -width 5] -row $row -column 6
+                         grid [button $main.cfefx($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.cfefx($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,x) -width 8] -row $row -column 4
+                         grid [entry $main.cfefxentry($phasenum,$bodnum,$mapnum) -textvariable ::rb($phasenum,$bodnum,$mapnum,x) -width 8] -row [expr $row + 1] -column 4
+                         grid [button $main.cfefy($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.cfefy($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,y) -width 8]  -row $row -column 5
+                         grid [entry $main.cfefyentry($phasenum,$bodnum,$mapnum) -textvariable ::rb($phasenum,$bodnum,$mapnum,y) -width 8] -row [expr $row + 1] -column 5
+                         grid [button $main.cfefz($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.cfefz($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,z) -width 8] -row $row -column 6
+                         grid [entry $main.cfefzentry($phasenum,$bodnum,$mapnum) -textvariable ::rb($phasenum,$bodnum,$mapnum,z) -width 8] -row [expr $row + 1] -column 6
                          grid [label $main.b1($phasenum,$bodnum,$mapnum) -text "   "] -row $row -column 7
 
-                         grid [button $main.eref1($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.eref1($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,e1) -width 5] -row $row -column 8
-                         grid [button $main.eref2($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.eref2($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,e2) -width 5] -row $row -column 9
-                         grid [button $main.eref3($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.eref3($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,e3) -width 5] -row $row -column 10
+                         grid [button $main.eref1($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.eref1($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,e1) -width 8] -row $row -column 8
+                         grid [entry $main.eref1entry($phasenum,$bodnum,$mapnum) -textvariable ::rb($phasenum,$bodnum,$mapnum,e1) -width 8] -row [expr $row + 1] -column 8
+                         grid [button $main.eref2($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.eref2($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,e2) -width 8] -row $row -column 9
+                         grid [entry $main.eref2entry($phasenum,$bodnum,$mapnum) -textvariable ::rb($phasenum,$bodnum,$mapnum,e2) -width 8] -row [expr $row + 1] -column 9
+                         grid [button $main.eref3($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.eref3($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,e3) -width 8] -row $row -column 10
+                         grid [entry $main.eref3entry($phasenum,$bodnum,$mapnum) -textvariable ::rb($phasenum,$bodnum,$mapnum,e3) -width 8] -row [expr $row + 1] -column 10
 #                         grid [label $main.b2($phasenum,$bodnum,$mapnum) -text "   "] -row $row -column 11
 
@@ -1757 +1778 @@
 
 
-                         grid [button $main.t11ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t11ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t11) -width 5] -row $row -column 12
-                         grid [button $main.t22ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t22ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t22) -width 5] -row $row -column 13
-                         grid [button $main.t33ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t33ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t33) -width 5] -row $row -column 14
-                         grid [button $main.t12ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t12ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t12) -width 5] -row $row -column 15
-                         grid [button $main.t13ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t13ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t13) -width 5] -row $row -column 16
-                         grid [button $main.t23ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t23ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t23) -width 5] -row $row -column 17
-                         grid [label $main.b3($phasenum,$bodnum,$mapnum) -text "   "] -row $row -column 18
-
-                         grid [button $main.l11ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l11ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l11) -width 5] -row $row -column 19
-                         grid [button $main.l22ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l22ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l22) -width 5] -row $row -column 20
-                         grid [button $main.l33ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l33ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l33) -width 5] -row $row -column 21
-                         grid [button $main.l12ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l12ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l12) -width 5] -row $row -column 22
-                         grid [button $main.l13ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l13ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l13) -width 5] -row $row -column 23
-                         grid [button $main.l23ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l23ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l23) -width 5] -row $row -column 24
+                         grid [button $main.t11ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t11ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t11) -width 8] -row $row -column 12
+                         grid [entry $main.t11entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,t11) -width 8] -row [expr $row + 1] -column 12
+                         grid [button $main.t22ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t22ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t22) -width 8] -row $row -column 13
+                         grid [entry $main.t22entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,t22) -width 8] -row [expr $row + 1] -column 13
+                         grid [button $main.t33ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t33ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t33) -width 8] -row $row -column 14
+                         grid [entry $main.t33entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,t33) -width 8] -row [expr $row + 1] -column 14
+                         grid [button $main.t12ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t12ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t12) -width 8] -row $row -column 15
+                         grid [entry $main.t12entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,t12) -width 8] -row [expr $row + 1] -column 15
+                         grid [button $main.t13ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t13ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t13) -width 8] -row $row -column 16
+                         grid [entry $main.t13entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,t13) -width 8] -row [expr $row + 1] -column 16
+                         grid [button $main.t23ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.t23ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,t23) -width 8] -row $row -column 17
+                         grid [entry $main.t23entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,t23) -width 8] -row [expr $row + 1] -column 17
+
+                         grid [button $main.l11ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l11ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l11) -width 8] -row $row -column 19
+                         grid [entry $main.l11entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,l11) -width 8] -row [expr $row + 1] -column 19
+                         grid [button $main.l22ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l22ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l22) -width 8] -row $row -column 20
+                         grid [entry $main.l22entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,l22) -width 8] -row [expr $row + 1] -column 20
+                         grid [button $main.l33ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l33ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l33) -width 8] -row $row -column 21
+                         grid [entry $main.l33entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,l33) -width 8] -row [expr $row + 1] -column 21
+                         grid [button $main.l12ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l12ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l12) -width 8] -row $row -column 22
+                         grid [entry $main.l12entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,l12) -width 8] -row [expr $row + 1] -column 22
+                         grid [button $main.l13ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l13ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l13) -width 8] -row $row -column 23
+                         grid [entry $main.l13entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,l13) -width 8] -row [expr $row + 1] -column 23
+                         grid [button $main.l23ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.l23ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,l23) -width 8] -row $row -column 24
+                         grid [entry $main.l23entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,l23) -width 8] -row [expr $row + 1] -column 24
+
                          grid [label $main.b4($phasenum,$bodnum,$mapnum) -text "   "] -row $row -column 25
 
-                         grid [button $main.s12ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s12ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s12) -width 5] -row $row -column 26
-                         grid [button $main.s13ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s13ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s13) -width 5] -row $row -column 27
-                         grid [button $main.s21ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s21ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s21) -width 5] -row $row -column 28
-                         grid [button $main.s23ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s23ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s23) -width 5] -row $row -column 29
-                         grid [button $main.s31ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s31ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s31) -width 5] -row $row -column 30
-                         grid [button $main.s32ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s32ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s32) -width 5] -row $row -column 31
-                         grid [button $main.saaref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.saaref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,saa) -width 5] -row $row -column 32
-                         grid [button $main.sbbref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.sbbref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,sbb) -width 5] -row $row -column 33
+                         grid [button $main.s12ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s12ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s12) -width 8] -row $row -column 26
+                         grid [entry $main.s12entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,s12) -width 8] -row [expr $row + 1] -column 26
+                         grid [button $main.s13ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s13ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s13) -width 8] -row $row -column 27
+                         grid [entry $main.s13entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,s13) -width 8] -row [expr $row + 1] -column 27
+                         grid [button $main.s21ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s21ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s21) -width 8] -row $row -column 28
+                         grid [entry $main.s21entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,s21) -width 8] -row [expr $row + 1] -column 28
+                         grid [button $main.s23ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s23ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s23) -width 8] -row $row -column 29
+                         grid [entry $main.s23entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,s23) -width 8] -row [expr $row + 1] -column 29
+                         grid [button $main.s31ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s31ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s31) -width 8] -row $row -column 30
+                         grid [entry $main.s31entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,s31) -width 8] -row [expr $row + 1] -column 30
+                         grid [button $main.s32ref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.s32ref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,s32) -width 8] -row $row -column 31
+                         grid [entry $main.s32entry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,s32) -width 8] -row [expr $row + 1] -column 31
+                         grid [button $main.saaref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.saaref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,saa) -width 8] -row $row -column 32
+                         grid [entry $main.saaentry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,saa) -width 8] -row [expr $row + 1] -column 32
+                         grid [button $main.sbbref($phasenum,$bodnum,$mapnum) -command "RB_Con_Button $main.sbbref($phasenum,$bodnum,$mapnum)" -textvariable ::rb_var($phasenum,$bodnum,$mapnum,sbb) -width 8] -row $row -column 33
+                         grid [entry $main.sbbentry($phasenum,$bodnum,$mapnum) -textvariable ::rb_tls($phasenum,$bodnum,$mapnum,sbb) -width 8] -row [expr $row + 1] -column 33
 
                          RB_TLS_Onoff $phasenum $main $bodnum $mapnum
@@ -1801 +1842 @@
                         grid [label $main.rb_site$phasenum$bodnum$mapnum \
                                   -text "atoms in rigid body:    $atomlist"] \
-                             -row [expr $row + 1] -column 4 -padx 5 -columnspan 999 -sticky w
-                        incr row 2
+                             -row [expr $row + 2] -column 4 -padx 5 -columnspan 999 -sticky w
+                        incr row 3
                      }
                  }
@@ -1821 +1862 @@
 
              grid [label $con.terminate.originlabel -text "Origin Damping Factor "] -row 5 -column 1
+
+
              eval tk_optionMenu $con.terminate.origindamp ::rb_damp_origin 0 1 2 3 4 5 6 7 8 9
-             grid $con.terminate.origindamp -row 5 -column 2
-             $con.terminate.origindamp config -width 4 -state disable
+             grid $con.terminate.origindamp -row 5 -column 3
+#             $con.terminate.origindamp config -width 4 -state disable
 
              grid [label $con.terminate.anglelabel -text "Angle Damping Factor "] -row 6 -column 1
-             eval tk_optionMenu $con.terminate.angledamp ::rb_damp_angle 0 1 2 3 4 5 6 7 8 9
-             grid $con.terminate.angledamp -row 6 -column 2
-             $con.terminate.angledamp config -width 4 -state disable
-
-             grid [button $con.terminate.save -width 22 -text "Assign Variables and Save" -command RB_Var_Assign] -row 7 -column 1 -columnspan 2
-             grid [button $con.terminate.abort -width 22 -text "Abort" -command  {destroy .refcon}] -row 8 -column 1 -columnspan 2
+             eval tk_optionMenu $con.terminate.angledamp ::rb_damp_euler 0 1 2 3 4 5 6 7 8 9
+             grid $con.terminate.angledamp -row 6 -column 3
+ #            $con.terminate.angledamp config -width 4 -state disable
+
+             grid [label $con.terminate.tls -text "TLS Damping Factors "] -row 7 -column 1
+             eval tk_optionMenu $con.terminate.t ::rb_damp_t "" 0 1 2 3 4 5 6 7 8 9
+             eval tk_optionMenu $con.terminate.l ::rb_damp_l "" 0 1 2 3 4 5 6 7 8 9
+             eval tk_optionMenu $con.terminate.s ::rb_damp_s "" 0 1 2 3 4 5 6 7 8 9
+             grid [label $con.terminate.t1 -text "T"] -row 7 -column 2
+             grid $con.terminate.t -row 7 -column 3
+#             $con.terminate.t config -state disable
+             grid [label $con.terminate.l1 -text "L"] -row 7 -column 4
+             grid $con.terminate.l -row 7 -column 5
+#             $con.terminate.l config -state disable
+             grid [label $con.terminate.s1 -text "S"] -row 7 -column 6
+             grid $con.terminate.s -row 7 -column 7
+#             $con.terminate.s config -state disable
+
+             grid [button $con.terminate.save -width 22 -text "Assign Variables and Save" -command RB_Var_Assign] -row 8 -column 1 -columnspan 2
+             grid [button $con.terminate.abort -width 22 -text "Abort" -command  {destroy .refcon}] -row 9 -column 1 -columnspan 2
 
 }
@@ -1894 +1951 @@
                      if {[lsearch $varlist [set $var]] == -1} {
                         lappend varlist [set $var]
-#                        puts $varlist
+                        puts $varlist
                         set rb_variable([set $var]) [RB_Var_Gen $varcount]
                         set $var $rb_variable([set $var])
@@ -1953 +2010 @@
                        set refcoordflag 0
                        set reftlsflag 0
-                       set rb_list "$::rb_var($phasenum,$bodnum,$mapnum,x) \
-                           $::rb_var($phasenum,$bodnum,$mapnum,y) $::rb_var($phasenum,$bodnum,$mapnum,z) \
-                           $::rb_var($phasenum,$bodnum,$mapnum,e1) $::rb_var($phasenum,$bodnum,$mapnum,e2) \
-                           $::rb_var($phasenum,$bodnum,$mapnum,e3) 0 0 0"
+                       set rb_list "$::rb_var($phasenum,$bodnum,$mapnum,e1) \
+                           $::rb_var($phasenum,$bodnum,$mapnum,e2) $::rb_var($phasenum,$bodnum,$mapnum,e3) \
+                           0 0 0 $::rb_var($phasenum,$bodnum,$mapnum,x) $::rb_var($phasenum,$bodnum,$mapnum,y) \
+                           $::rb_var($phasenum,$bodnum,$mapnum,z)"
+#                       puts "param saved for map $phasenum $bodnum $mapnum is vvvvvvv $rb_list"
                        RigidBodyVary $phasenum $bodnum $mapnum $rb_list
                        RecordMacroEntry "incr expgui(changed); RigidBodyVary $phasenum $bodnum $mapnum [list $rb_list]" 0
@@ -1977 +2035 @@
                                $::rb_var($phasenum,$bodnum,$mapnum,s31) $::rb_var($phasenum,$bodnum,$mapnum,s32) \
                                $::rb_var($phasenum,$bodnum,$mapnum,saa) $::rb_var($phasenum,$bodnum,$mapnum,sbb)"
-#                           puts "TLS param save for $rb_tls"
+                           set rb_tls_vals "$::rb_tls($phasenum,$bodnum,$mapnum,t11) $::rb_tls($phasenum,$bodnum,$mapnum,t22) \
+                               $::rb_tls($phasenum,$bodnum,$mapnum,t33) $::rb_tls($phasenum,$bodnum,$mapnum,t12) \
+                               $::rb_tls($phasenum,$bodnum,$mapnum,t13) $::rb_tls($phasenum,$bodnum,$mapnum,t23) \
+                               $::rb_tls($phasenum,$bodnum,$mapnum,l11) $::rb_tls($phasenum,$bodnum,$mapnum,l22) \
+                               $::rb_tls($phasenum,$bodnum,$mapnum,l33) $::rb_tls($phasenum,$bodnum,$mapnum,l12) \
+                               $::rb_tls($phasenum,$bodnum,$mapnum,l13) $::rb_tls($phasenum,$bodnum,$mapnum,l23) \
+                               $::rb_tls($phasenum,$bodnum,$mapnum,s12) $::rb_tls($phasenum,$bodnum,$mapnum,s13) \
+                               $::rb_tls($phasenum,$bodnum,$mapnum,s21) $::rb_tls($phasenum,$bodnum,$mapnum,s23) \
+                               $::rb_tls($phasenum,$bodnum,$mapnum,s31) $::rb_tls($phasenum,$bodnum,$mapnum,s32) \
+                               $::rb_tls($phasenum,$bodnum,$mapnum,saa) $::rb_tls($phasenum,$bodnum,$mapnum,sbb)"
+
+                            set rb_damping "$::rb_damp_euler $::rb_damp_euler $::rb_damp_euler \
+                                $::rb_damp_euler $::rb_damp_euler $::rb_damp_euler \
+                                $::rb_damp_origin $::rb_damp_origin $::rb_damp_origin"
+                            set rb_damping_tls "$::rb_damp_t $::rb_damp_l $::rb_damp_s"
+                            puts "tls damping = $rb_damping_tls"
+#                            puts "rb damping = $rb_damping"
+
+
+#                            RigidBodySetDamp $phasenum $bodnum $mapnum $rb_damping $rb_damping_tls
+                            
+                            if {$::rb_var($phasenum,$bodnum,$mapnum,tls) == 0} {
+                                  RigidBodySetDamp $phasenum $bodnum $mapnum $rb_damping 
+                            } else {
+                                  RigidBodySetDamp $phasenum $bodnum $mapnum $rb_damping $rb_damping_tls
+                            }
+
+#                           puts "TLS Values to be saved = $rb_tls_vals"
+                            set rb_tls_positions "$::rb($phasenum,$bodnum,$mapnum,x) $::rb($phasenum,$bodnum,$mapnum,y) \
+                               $::rb($phasenum,$bodnum,$mapnum,z)"
+                            set rb_tls_euler "$::rb($phasenum,$bodnum,$mapnum,e1) $::rb($phasenum,$bodnum,$mapnum,e2) \
+                               $::rb($phasenum,$bodnum,$mapnum,e3)"
+#                           puts "origin positions = $rb_tls_positions"
+#                           puts "euler angles = $rb_tls_euler"
+
+#                           puts "TLS param save for $mapnum $bodnum $mapnum is vvvvvvvv $rb_tls"
+                           RigidBodySetTLS $phasenum $bodnum $mapnum $rb_tls_vals
+                           EditRigidBodyMapping $phasenum $bodnum $mapnum $rb_tls_positions $rb_tls_euler
+#                           RecordMacroEntry "RigidBodySetTLS $phasenum $bodnum $mapnum $rb_tls_vals"
+
                            RigidBodyTLSVary $phasenum $bodnum $mapnum $rb_tls
                            RecordMacroEntry "RigidBodyTLSVary $phasenum $bodnum $mapnum [list $rb_tls]" 0
@@ -2010 +2107 @@
               $main.s23ref($phasenum,$bodnum,$mapnum) $main.s31ref($phasenum,$bodnum,$mapnum) $main.s32ref($phasenum,$bodnum,$mapnum) \
               $main.saaref($phasenum,$bodnum,$mapnum) $main.sbbref($phasenum,$bodnum,$mapnum)
+
+      lappend tlsentry $main.t11entry($phasenum,$bodnum,$mapnum) $main.t22entry($phasenum,$bodnum,$mapnum) $main.t33entry($phasenum,$bodnum,$mapnum) \
+              $main.t12entry($phasenum,$bodnum,$mapnum) $main.t13entry($phasenum,$bodnum,$mapnum) $main.t23entry($phasenum,$bodnum,$mapnum) \
+              $main.l11entry($phasenum,$bodnum,$mapnum) $main.l22entry($phasenum,$bodnum,$mapnum) $main.l33entry($phasenum,$bodnum,$mapnum) \
+              $main.l12entry($phasenum,$bodnum,$mapnum) $main.l13entry($phasenum,$bodnum,$mapnum) $main.l23entry($phasenum,$bodnum,$mapnum) \
+              $main.s12entry($phasenum,$bodnum,$mapnum) $main.s13entry($phasenum,$bodnum,$mapnum) $main.s21entry($phasenum,$bodnum,$mapnum) \
+              $main.s23entry($phasenum,$bodnum,$mapnum) $main.s31entry($phasenum,$bodnum,$mapnum) $main.s32entry($phasenum,$bodnum,$mapnum) \
+              $main.saaentry($phasenum,$bodnum,$mapnum) $main.sbbentry($phasenum,$bodnum,$mapnum)
+
 #      puts $tlsparam
               if {$::rb_var($phasenum,$bodnum,$mapnum,tls) == 0} {
@@ -2016 +2122 @@
                                 $x config -state disable -relief sunken
                         }
+                        foreach x $tlsentry {
+                                $x config -state disable
+                        }
               } else {
                         RigidBodyEnableTLS $phasenum $bodnum $mapnum 1
@@ -2021 +2130 @@
                                 $x config -state normal -relief raised
                         }
+                        foreach x $tlsentry {
+                                $x config -state normal
+                        }
               }
 }
@@ -2026 +2138 @@
 
 proc RB_Load_Vars {phasenum bodnum mapnum args} {
-     foreach var $::rb_map_positionvars($phasenum,$bodnum,$mapnum) {
-             catch {unset temp($var)}
-     }
-
-     foreach var $::rb_map_positionvars($phasenum,$bodnum,$mapnum) {
-             if {[info exists temp($var)] == "0"} {
-                set temp($var) $var
-                } else {
-                  lappend mulvarlist $var
-             }
-     }
-
-     foreach var $::rb_map_tls_var($phasenum,$bodnum,$mapnum) {
-             if {[info exists temp($var)] == "0"} {
-                set temp($var) $var
-             } else {
-                lappend mulvarlist $var
-             }
-     }
-
-     set ::rb_var($phasenum,$bodnum,$mapnum,x) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 0] $mulvarlist]
-     set ::rb_var($phasenum,$bodnum,$mapnum,y) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 1] $mulvarlist]
-     set ::rb_var($phasenum,$bodnum,$mapnum,z) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 2] $mulvarlist]
+#     foreach var $::rb_map_positionvars($phasenum,$bodnum,$mapnum) {
+#             catch {unset temp($var)}
+#     }
+#
+#     foreach var $::rb_map_positionvars($phasenum,$bodnum,$mapnum) {
+#            if {[info exists temp($var)] == "0"} {
+#                set temp($var) $var
+#                } else {
+#                  lappend mulvarlist $var
+#             }
+#    }
+#
+#    foreach var $::rb_map_tls_var($phasenum,$bodnum,$mapnum) {
+#             if {[info exists temp($var)] == "0"} {
+#                set temp($var) $var
+#             } else {
+#                lappend mulvarlist $var
+#             }
+#     }
+#     puts "the mulvarlist is     $mulvarlist"
+
+#     8Aug12    new code to determine variable names
+     set rb_num [RigidBodyList]
+     set varlist ""
+     set mvarlist ""
+     foreach phase $::expmap(phaselist) {
+          foreach bod $rb_num {
+               set rb_map_num($phase,$bod) [RigidBodyMappingList $phase $bod]
+               if {$rb_map_num($phase,$bod) != ""} {
+                  foreach map $rb_map_num($phase,$bod) {
+                           foreach var $::rb_map_positionvars($phase,$bod,$map) {
+                                    set temp1 [lsearch $varlist $var]
+                                    if {$temp1 == "-1"} {lappend varlist $var
+                                       } else {
+                                           if {[lsearch $mvarlist $var] == "-1"} {lappend mvarlist $var}
+                                       }
+                           }
+                           foreach var $::rb_map_tls_var($phase,$bod,$map) {
+                                    set temp1 [lsearch $varlist $var]
+                                    if {$temp1 == "-1"} {lappend varlist $var
+                                       } else {
+                                           if {[lsearch $mvarlist $var] == "-1"} {lappend mvarlist $var}
+                                       }
+                          }
+                   }
+               }
+          }
+     }
+#     puts "varlist    $varlist"
+#     puts "mvarlist   $mvarlist"
+
+     set ::rb_var($phasenum,$bodnum,$mapnum,x) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 6] $mvarlist $varlist]
+     set ::rb_var($phasenum,$bodnum,$mapnum,y) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 7] $mvarlist $varlist]
+     set ::rb_var($phasenum,$bodnum,$mapnum,z) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 8] $mvarlist $varlist]
 
      lappend ::rb_var_list ::rb_var($phasenum,$bodnum,$mapnum,x) ::rb_var($phasenum,$bodnum,$mapnum,y) ::rb_var($phasenum,$bodnum,$mapnum,z)
 
-     set ::rb_var($phasenum,$bodnum,$mapnum,e1) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 3] $mulvarlist]
-     set ::rb_var($phasenum,$bodnum,$mapnum,e2) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 4] $mulvarlist]
-     set ::rb_var($phasenum,$bodnum,$mapnum,e3) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 5] $mulvarlist]
+     set ::rb_var($phasenum,$bodnum,$mapnum,e1) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 0] $mvarlist $varlist]
+     set ::rb_var($phasenum,$bodnum,$mapnum,e2) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 1] $mvarlist $varlist]
+     set ::rb_var($phasenum,$bodnum,$mapnum,e3) [RB_VarSet [lindex $::rb_map_positionvars($phasenum,$bodnum,$mapnum) 2] $mvarlist $varlist]
 
      lappend ::rb_var_list ::rb_var($phasenum,$bodnum,$mapnum,e1) ::rb_var($phasenum,$bodnum,$mapnum,e2) ::rb_var($phasenum,$bodnum,$mapnum,e3)
 
+     ### create variables containing origin, euler angles and tls terms 14 Aug 2012
+
+     set ::rb($phasenum,$bodnum,$mapnum,x) [lindex $::rb_map_origin($phasenum,$bodnum,$mapnum) 0]
+     set ::rb($phasenum,$bodnum,$mapnum,y) [lindex $::rb_map_origin($phasenum,$bodnum,$mapnum) 1]
+     set ::rb($phasenum,$bodnum,$mapnum,z) [lindex $::rb_map_origin($phasenum,$bodnum,$mapnum) 2]
+
+     set ::rb($phasenum,$bodnum,$mapnum,e1) [lindex [lindex $::rb_map_euler($phasenum,$bodnum,$mapnum) 0] 0]
+     set ::rb($phasenum,$bodnum,$mapnum,e2) [lindex [lindex $::rb_map_euler($phasenum,$bodnum,$mapnum) 1] 0]
+     set ::rb($phasenum,$bodnum,$mapnum,e3) [lindex [lindex $::rb_map_euler($phasenum,$bodnum,$mapnum) 2] 0]
+
+     set ::rb_tls($phasenum,$bodnum,$mapnum,t11) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 0]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,t22) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 1]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,t33) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 2]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,t12) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 3]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,t13) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 4]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,t23) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 5]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,l11) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 6]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,l22) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 7]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,l33) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 8]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,l12) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 9]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,l13) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 10]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,l23) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 11]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,s12) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 12]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,s13) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 13]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,s21) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 14]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,s23) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 15]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,s31) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 16]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,s32) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 17]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,saa) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 18]
+     set ::rb_tls($phasenum,$bodnum,$mapnum,sbb) [lindex $::rb_map_tls($phasenum,$bodnum,$mapnum) 19]
+
+
      if {$::rb_map_tls_var($phasenum,$bodnum,$mapnum) != ""} {
 
 
-          set ::rb_var($phasenum,$bodnum,$mapnum,t11) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 0] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,t22) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 1] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,t33) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 2] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,t12) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 3] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,t13) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 4] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,t23) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 5] $mulvarlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,t11) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 0] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,t22) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 1] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,t33) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 2] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,t12) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 3] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,t13) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 4] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,t23) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 5] $mvarlist $varlist]
 
           lappend ::rb_var_list_tls ::rb_var($phasenum,$bodnum,$mapnum,t11) ::rb_var($phasenum,$bodnum,$mapnum,t22) ::rb_var($phasenum,$bodnum,$mapnum,t33)
           lappend ::rb_var_list_tls ::rb_var($phasenum,$bodnum,$mapnum,t12) ::rb_var($phasenum,$bodnum,$mapnum,t13) ::rb_var($phasenum,$bodnum,$mapnum,t23)
 
-          set ::rb_var($phasenum,$bodnum,$mapnum,l11) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 6] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,l22) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 7] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,l33) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 8] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,l12) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 9] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,l13) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 10] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,l23) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 11] $mulvarlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,l11) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 6] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,l22) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 7] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,l33) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 8] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,l12) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 9] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,l13) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 10] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,l23) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 11] $mvarlist $varlist]
 
           lappend ::rb_var_list_tls ::rb_var($phasenum,$bodnum,$mapnum,l11) ::rb_var($phasenum,$bodnum,$mapnum,l22) ::rb_var($phasenum,$bodnum,$mapnum,l33)
           lappend ::rb_var_list_tls ::rb_var($phasenum,$bodnum,$mapnum,l12) ::rb_var($phasenum,$bodnum,$mapnum,l13) ::rb_var($phasenum,$bodnum,$mapnum,l23)
 
-          set ::rb_var($phasenum,$bodnum,$mapnum,s12) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 12] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,s13) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 13] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,s21) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 14] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,s23) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 15] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,s31) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 16] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,s32) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 17] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,saa) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 18] $mulvarlist]
-          set ::rb_var($phasenum,$bodnum,$mapnum,sbb) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 19] $mulvarlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,s12) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 12] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,s13) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 13] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,s21) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 14] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,s23) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 15] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,s31) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 16] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,s32) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 17] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,saa) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 18] $mvarlist $varlist]
+          set ::rb_var($phasenum,$bodnum,$mapnum,sbb) [RB_VarSet [lindex $::rb_map_tls_var($phasenum,$bodnum,$mapnum) 19] $mvarlist $varlist]
 
           lappend ::rb_var_list_tls ::rb_var($phasenum,$bodnum,$mapnum,s12) ::rb_var($phasenum,$bodnum,$mapnum,s13) ::rb_var($phasenum,$bodnum,$mapnum,s21)
@@ -2135 +2310 @@
 }
 
-proc RB_VarSet {varin mulvarlist args} {
-     if {$varin == 0} {set varout ""
+proc RB_VarSet {varin mvarlist varlist args} {
+     set temp [lsearch $mvarlist $varin]
+     if {$temp == "-1"} {set varout "free"
         } else {
-          set temp [lsearch $mulvarlist $varin]
-          if {$temp == "-1"} {set varout "free"
-                 } else {
-                   set varout var$varin
-              }
-     }
+          set varout var$varin
+        }
+     if {$varin == 0} {set varout ""}
      return $varout
+
+
+ #    if {$varin == 0} {set varout ""
+ #       } else {
+ #         set temp [lsearch $mulvarlist $varin]
+ #         if {$temp == "-1"} {set varout "free"
+ #                } else {
+ #                  set varout var$varin
+ #             }
+ #    }
+ #    return $varout
 }