source: trunk/readexp.tcl @ 544

Last change on this file since 544 was 544, checked in by toby, 11 years ago

# on 2002/01/22 23:02:55, toby did:
writing of real values: if a field has more than 6 characters &
too few significant digits will show, switch to scientific notation
-- example: set val .001234; validreal val 8 4 -- val is 0.0012

set val .0001234; validreal val 8 4 -- val is 1.23E-04

new routine for MM phases: mmatominfo
add abs correction parameters to histinfo
handle mm constraints in constrinfo

  • Property rcs:author set to toby
  • Property rcs:date set to 2002/01/22 23:02:55
  • Property rcs:lines set to +240 -15
  • Property rcs:rev set to 1.34
  • Property rcs:state set to Exp
  • Property svn:keywords set to Author Date Revision Id
File size: 68.6 KB
Line 
1# $Id: readexp.tcl 544 2009-12-04 23:07:57Z toby $
2# Routines to deal with the .EXP "data structure"
3set expmap(Revision) {$Revision: 544 $ $Date: 2009-12-04 23:07:57 +0000 (Fri, 04 Dec 2009) $}
4
5#  The GSAS data is read from an EXP file.
6#   ... reading an EXP file into an array
7# returns -1 on error
8# returns 0 if the file is old-style UNIX format (no CR/LF)
9# returns 1 if the file is 80 char/line + cr/lf
10# returns 2 if the file is sequential but not fixed-record length
11proc expload {expfile} {
12    global exparray tcl_platform
13    # $expfile is the path to the data file.
14
15    if [catch {set fil [open "$expfile" r]}] {
16        tk_dialog .expFileErrorMsg "File Open Error" \
17                "Unable to open file $expfile" error 0 "Exit" 
18        return -1
19    }
20    fconfigure $fil -translation lf
21    set len [gets $fil line]
22    if {[string length $line] != $len} {
23        tk_dialog .expConvErrorMsg "old tcl" \
24                "You are using an old version of Tcl/Tk and your .EXP file has binary characters; run convstod or upgrade" \
25                error 0 "Exit"
26        return -1
27    }
28    catch {
29        unset exparray
30    }
31    if {$len > 160} {
32        set fmt 0
33        # a UNIX-type file
34        set i1 0
35        set i2 79
36        while {$i2 < $len} {
37            set nline [string range $line $i1 $i2]
38            incr i1 80
39            incr i2 80
40            set key [string range $nline 0 11]
41            set exparray($key) [string range $nline 12 end]
42        }
43    } else {
44        set fmt 1
45        while {$len > 0} {
46            set key [string range $line 0 11]
47            set exparray($key) [string range $line 12 79]
48            if {$len != 81 || [string range $line end end] != "\r"} {set fmt 2}
49            set len [gets $fil line]
50        }
51    }
52    close $fil
53    return $fmt
54}
55
56proc createexp {expfile title} {
57    global exparray expmap
58    catch {unset exparray}
59    foreach key   {"     VERSION" "      DESCR" "ZZZZZZZZZZZZ" " EXPR NPHAS"} \
60            value {"   6"         ""            "  Last EXP file record" ""} {
61        # truncate long keys & pad short ones
62        set key [string range "$key        " 0 11]
63        set exparray($key) $value
64    }
65    expinfo title set $title
66    exphistory add " created readexp.tcl [lindex $expmap(Revision) 1] [clock format [clock seconds]]"
67    expwrite $expfile
68}
69
70# get information out from an EXP file
71#   creates the following entries in global array expmap
72#     expmap(phaselist)     gives a list of defined phases
73#     expmap(phasetype)     gives the phase type for each defined phase
74#                           =1 nuclear; 2 mag+nuc; 3 mag; 4 macro
75#     expmap(atomlist_$p)   gives a list of defined atoms in phase $p
76#     expmap(htype_$n)      gives the GSAS histogram type for histogram (all)
77#     expmap(powderlist)    gives a list of powder histograms in use
78#     expmap(phaselist_$n)  gives a list of phases used in histogram $n
79#     expmap(nhst)          the number of GSAS histograms
80#
81proc mapexp {} {
82    global expmap exparray
83    # clear out the old array
84    set expmap_Revision $expmap(Revision)
85    unset expmap
86    set expmap(Revision) $expmap_Revision
87    # get the defined phases
88    set line [readexp " EXPR NPHAS"]
89#    if {$line == ""} {
90#       set msg "No EXPR NPHAS entry. This is an invalid .EXP file"
91#       tk_dialog .badexp "Error in EXP" $msg error 0 Exit
92#       destroy .
93#    }
94    set expmap(phaselist) {}
95    set expmap(phasetype) {}
96    # loop over phases
97    foreach iph {1 2 3 4 5 6 7 8 9} {
98        set i5s [expr {($iph - 1)*5}]
99        set i5e [expr {$i5s + 4}]
100        set flag [string trim [string range $line $i5s $i5e]]
101        if {$flag == ""} {set flag 0}
102        if $flag {
103            lappend expmap(phaselist) $iph
104            lappend expmap(phasetype) $flag
105        }
106    }
107    # get the list of defined atoms for each phase
108    foreach iph $expmap(phaselist) {
109        set expmap(atomlist_$iph) {}
110        if {[lindex $expmap(phasetype) [expr {$iph - 1}]] != 4} {
111            foreach key [array names exparray "CRS$iph  AT*A"] {
112                regexp { AT *([0-9]+)A} $key a num
113                lappend expmap(atomlist_$iph) $num
114            }
115        } else {
116            foreach key [array names exparray "CRS$iph  AT*"] {
117                lappend expmap(atomlist_$iph) [scan [string range $key 8 11] %x]
118            }
119        }
120        # note that sometimes an .EXP file contains more atoms than are actually defined
121        # drop the extra ones
122        set expmap(atomlist_$iph) [lsort -integer $expmap(atomlist_$iph)]
123        set natom [phaseinfo $iph natoms]
124        if {$natom != [llength $expmap(atomlist_$iph)]} {
125            set expmap(atomlist_$iph) [lrange $expmap(atomlist_$iph) 0 [expr {$natom-1}]]
126        }
127    }
128    # now get the histogram types
129    set expmap(nhst) [string trim [readexp { EXPR  NHST }]]
130    set n 0
131    set expmap(powderlist) {}
132    for {set i 0} {$i < $expmap(nhst)} {incr i} {
133        set ihist [expr {$i + 1}]
134        if {[expr {$i % 12}] == 0} {
135            incr n
136            set line [readexp " EXPR  HTYP$n"]
137            if {$line == ""} {
138                set msg "No HTYP$n entry for Histogram $ihist. This is an invalid .EXP file"
139                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
140            }
141            set j 0
142        } else {
143            incr j
144        }
145        set expmap(htype_$ihist) [string range $line [expr 2+5*$j] [expr 5*($j+1)]]
146        # is this a dummy histogram?
147        if {$ihist <=9} {
148            set key "HST  $ihist DUMMY"
149        } else {
150            set key "HST $ihist DUMMY"
151        }
152        # at least for now, ignore non-powder histograms
153        if {[string range $expmap(htype_$ihist) 0 0] == "P" && \
154                [string range $expmap(htype_$ihist) 3 3] != "*"} {
155            if {[existsexp $key]} {
156                set expmap(htype_$ihist) \
157                        [string range $expmap(htype_$ihist) 0 2]D
158            }
159            lappend expmap(powderlist) $ihist
160        }
161    }
162
163    # now process powder histograms
164    foreach ihist $expmap(powderlist) {
165        # make a 2 digit key -- hh
166        if {$ihist < 10} {
167            set hh " $ihist"
168        } else {
169            set hh $ihist
170        }
171        set line [readexp "HST $hh NPHAS"]
172        if {$line == ""} {
173            set msg "No NPHAS entry for Histogram $ihist. This is an invalid .EXP file"
174            tk_dialog .badexp "Error in readexp" $msg error 0 Exit
175        }
176        set expmap(phaselist_$ihist) {}
177        # loop over phases
178        foreach iph {1 2 3 4 5 6 7 8 9} {
179            set i5s [expr {($iph - 1)*5}]
180            set i5e [expr {$i5s + 4}]
181            set flag [string trim [string range $line $i5s $i5e]]
182            if {$flag == ""} {set flag 0}
183            if $flag {lappend expmap(phaselist_$ihist) $iph}
184        }
185    }
186}
187
188# return the value for a ISAM key
189proc readexp {key} {
190    global exparray
191    # truncate long keys & pad short ones
192    set key [string range "$key        " 0 11]
193    if [catch {set val $exparray($key)}] {
194        global expgui
195        if $expgui(debug) {puts "Error accessing record $key"}
196        return ""
197    }
198    return $val
199}
200
201# return the number of records matching ISAM key (may contain wildcards)
202proc existsexp {key} {
203    global exparray
204    # key can contain wild cards so don't pad
205    return [llength [array names exparray  $key]]
206}
207
208
209# replace a section of the exparray with $value
210#   replace $char characters starting at character $start (numbered from 1)
211proc setexp {key value start chars} {
212    global exparray
213    # truncate long keys & pad short ones
214    set key [string range "$key        " 0 11]
215    if [catch {set exparray($key)}] {
216        global expgui
217        if $expgui(debug) {puts "Error accessing record $key"}
218        return ""
219    }
220
221    # pad value to $chars
222    set l0 [expr {$chars - 1}]
223    set value [string range "$value                                           " 0 $l0]
224
225    if {$start == 1} {
226        set ret {}
227        set l1 $chars
228    } else {
229        set l0 [expr {$start - 2}]
230        set l1 [expr {$start + $chars - 1}]
231        set ret [string range $exparray($key) 0 $l0]
232    }
233    append ret $value [string range $exparray($key) $l1 end]
234    set exparray($key) $ret
235}
236
237proc makeexprec {key} {
238    global exparray
239    # truncate long keys & pad short ones
240    set key [string range "$key        " 0 11]
241    if [catch {set exparray($key)}] {
242        # set to 68 blanks
243        set exparray($key) [format %68s " "]
244    }
245}
246
247# delete an exp record
248# returns 1 if OK; 0 if not found
249proc delexp {key} {
250    global exparray
251    # truncate long keys & pad short ones
252    set key [string range "$key        " 0 11]
253    if [catch {unset exparray($key)}] {
254        return 0
255    }
256    return 1
257}
258# test an argument if it is a valid number; reform the number to fit
259proc validreal {val length decimal} {
260    upvar $val value
261    if [catch {expr {$value}}] {return 0}
262    if [catch {
263        # for small values, switch to exponential notation
264        set pow [expr .2 - $decimal]
265        if {abs($value) < pow(10,$pow) && $length > 6} {
266            set tmp [format "%${length}.${decimal}E" $value]
267        } else {
268            set tmp [format "%${length}.${decimal}f" $value]
269        }
270        # if the string will not fit, use scientific notation & drop
271        # digits, as needed
272        while {[string length $tmp] > $length && $decimal >= 0} {
273            set tmp [format "%${length}.${decimal}E" $value]
274            incr decimal -1
275        }
276        set value $tmp
277    }] {return 0}
278    return 1
279}
280
281# test an argument if it is a valid integer; reform the number into
282# an integer, if appropriate -- be sure to pass the name of the variable not the value
283proc validint {val length} {
284    upvar $val value
285    # FORTRAN type assumption: blank is 0
286    if {$value == ""} {set value 0}
287    if [catch {
288        set tmp [expr {round($value)}]
289        if {$tmp != $value} {return 0}
290        set value [format "%${length}d" $tmp]
291    }] {return 0}
292    return 1
293}
294
295# process history information
296#    action == last
297#       returns number and value of last record
298#    action == add
299#
300proc exphistory {action "value 0"} {
301    global exparray
302    if {$action == "last"} {
303        set key [lindex [lsort -decreasing [array names exparray *HSTRY*]] 0]
304        if {$key == ""} {return ""}
305        return [list [string trim [string range $key 9 end]] $exparray($key)]
306    } elseif {$action == "add"} {
307        set key [lindex [lsort -decreasing [array names exparray *HSTRY*]] 0]
308        if {$key == ""} {
309            set index 1
310        } else {
311            set index [string trim [string range $key 9 end]]
312            if {$index != "***"} {
313                if {$index < 999} {incr index}
314                set key [format "    HSTRY%3d" $index]
315                set exparray($key) $value
316            }
317        }
318        set key [format "    HSTRY%3d" $index]
319        set exparray($key) $value
320    }
321}
322# get overall info
323#   parm:
324#     print     -- GENLES print option (*)
325#     cycles    -- number of GENLES cycles (*)
326#     title     -- the overall title (*)
327#     convg     -- convergence criterion: -200 to 200 (*)
328#     marq      -- Marquardt damping factor: 1.0 to 9.99 (*)
329proc expinfo {parm "action get" "value {}"} {
330    switch ${parm}-$action {
331        title-get {
332            return [string trim [readexp "      DESCR"]]
333        }
334        title-set {
335            setexp "      DESCR" "  $value" 2 68
336        }
337        cycles-get {
338            return [string trim [cdatget MXCY]]
339        }
340        cycles-set {
341            if ![validint value 1] {return 0}
342            cdatset MXCY [format %4d $value]
343        }
344        cyclesrun-get {
345            set cycle -1
346            regexp {.*cycles run *([0-9]*) } [readexp "  GNLS  RUN"] x cycle
347            return $cycle
348        }
349        print-get {
350            set print [string trim [cdatget PRNT]]
351            if {$print != ""} {return $print}
352            return 0
353        }
354        print-set {
355            if ![validint value 1] {return 0}
356            cdatset PRNT [format %3d $value]
357        }
358        convg-get {
359            set cvg [string trim [cdatget CVRG]]
360            if {$cvg == ""} {return -200}
361            if [catch {expr {$cvg}}] {return -200}
362            return $cvg
363        }
364        convg-set {
365            if ![validint value 1] {return 0}
366            set value [expr {-200>$value?-200:$value}]
367            set value [expr {200<$value?200:$value}]
368            cdatset CVRG [format %4d $value]
369        }
370        marq-get {
371            set mar [string trim [cdatget MARQ]]
372            if {$mar == ""} {return 1.0}
373            if [catch {expr $mar}] {return 1.}
374            return $mar
375        }
376        marq-set {
377            if [catch {
378                set value [expr {1.0>$value?1.0:$value}]
379                set value [expr {9.99<$value?9.99:$value}]
380            }] {return 0}
381            if ![validreal value 4 2] {return 0}
382            cdatset MARQ $value
383        }
384        default {
385            set msg "Unsupported expinfo access: parm=$parm action=$action"
386            tk_dialog .badexp "Error in readexp" $msg error 0 Exit
387        }
388    }
389    return 1
390}
391
392proc cdatget {key} {
393    foreach i {1 2 3 4 5 6 7 8 9} {
394        if {[existsexp "  GNLS CDAT$i"] == 0} break
395        set line [readexp "  GNLS CDAT$i"]
396        if {$line == {}} break
397        foreach i1 {2 10 18 26 34 42 50 58 66} \
398                i2 {9 17 25 33 41 49 57 65 73} {
399            set item [string range $line $i1 $i2]
400            if {[string trim $item] == {}} continue
401            if [regexp "${key}(.*)" $item a b] {return $b}
402        }
403    }
404    return {}
405}
406
407proc cdatset {key value} {
408    # round 1 see if we can find the string
409    foreach i {1 2 3 4 5 6 7 8 9} {
410        set line [readexp "  GNLS CDAT$i"]
411        if {$line == {}} break
412        foreach i1 {2 10 18 26 34 42 50 58 66} \
413                i2 {9 17 25 33 41 49 57 65 73} {
414            set item [string range $line $i1 $i2]
415            if {[string trim $item] == {}} continue
416            if [regexp "${key}(.*)" $item a b] {
417                # found it now replace it
418                incr i1
419                setexp "  GNLS CDAT$i" "${key}${value}" $i1 8
420                return
421            }
422        }
423    }
424    # not found, take the 1st blank space, creating a card if needed
425    foreach i {1 2 3 4 5 6 7 8 9} {
426        set line [readexp "  GNLS CDAT$i"]
427        if {$line == {}} {makeexprec "  GNLS CDAT$i"}
428        foreach i1 {2 10 18 26 34 42 50 58 66} \
429                i2 {9 17 25 33 41 49 57 65 73} {
430            set item [string range $line $i1 $i2]
431            if {[string trim $item] == {}} {
432                # found a blank space: now replace it
433                incr i1
434                setexp "  GNLS CDAT$i" "${key}${value}" $i1 8
435                return
436            }
437        }
438    }
439    return {}
440}
441
442# get phase information: phaseinfo phase parm action value
443#   phase: 1 to 9 (as defined)
444#   parm:
445#     name -- phase name
446#     natoms -- number of atoms (*)
447#     a b c alpha beta gamma -- cell parameters (*)
448#     cellref -- refinement flag for the unit cell(*)
449#     celldamp  -- damping for the unit cell refinement (*)
450#     spacegroup -- space group symbol (*)
451#     ODForder -- spherical harmonic order (*)
452#     ODFsym   -- sample symmetry (0-3) (*)
453#     ODFdampA -- damping for angles (*)
454#     ODFdampC -- damping for coefficients (*)
455#     ODFomega -- omega oriention angle (*)
456#     ODFchi -- chi oriention angle (*)
457#     ODFphi -- phi oriention angle (*)
458#     ODFomegaRef -- refinement flag for omega (*)
459#     ODFchiRef -- refinement flag for chi (*)
460#     ODFphiRef -- refinement flag for phi (*)
461#     ODFterms -- a list of the {l m n} values for each ODF term (*)
462#     ODFcoefXXX -- the ODF coefficient for for ODF term XXX (*)
463#     ODFRefcoef -- refinement flag for ODF terms (*)
464#  action: get (default) or set
465#  value: used only with set
466#  * =>  read+write supported
467proc phaseinfo {phase parm "action get" "value {}"} {
468    switch -glob ${parm}-$action {
469
470        name-get {
471            return [string trim [readexp "CRS$phase    PNAM"]]
472        }
473
474        name-set {
475            setexp "CRS$phase    PNAM" " $value" 2 68
476        }
477
478        spacegroup-get {
479            return [string trim [readexp "CRS$phase  SG SYM"]]
480        }
481
482        spacegroup-set {
483            setexp "CRS$phase  SG SYM" " $value" 2 68
484        }
485
486        natoms-get {
487            return [string trim [readexp "CRS$phase   NATOM"]]     
488        }
489
490        natoms-set {
491            if ![validint value 5] {return 0}
492            setexp "CRS$phase   NATOM" $value 1 5
493        }
494
495        a-get {
496           return [string trim [string range [readexp "CRS$phase  ABC"] 0 9]]
497        }
498        b-get {
499           return [string trim [string range [readexp "CRS$phase  ABC"] 10 19]]
500        }
501        c-get {
502           return [string trim [string range [readexp "CRS$phase  ABC"] 20 29]]
503        }
504        alpha-get {
505           return [string trim [string range [readexp "CRS$phase  ANGLES"] 0 9]]
506        }
507        beta-get {
508           return [string trim [string range [readexp "CRS$phase  ANGLES"] 10 19]]
509        }
510        gamma-get {
511           return [string trim [string range [readexp "CRS$phase  ANGLES"] 20 29]]
512        }
513
514        a-set {
515            if ![validreal value 10 6] {return 0}
516            setexp "CRS$phase  ABC" $value 1 10             
517        }
518        b-set {
519            if ![validreal value 10 6] {return 0}
520            setexp "CRS$phase  ABC" $value 11 10           
521        }
522        c-set {
523            if ![validreal value 10 6] {return 0}
524            setexp "CRS$phase  ABC" $value 21 10           
525        }
526        alpha-set {
527            if ![validreal value 10 4] {return 0}
528            setexp "CRS$phase  ANGLES" $value 1 10         
529        }
530        beta-set {
531            if ![validreal value 10 4] {return 0}
532            setexp "CRS$phase  ANGLES" $value 11 10         
533        }
534        gamma-set {
535            if ![validreal value 10 4] {return 0}
536            setexp "CRS$phase  ANGLES" $value 21 10         
537        }
538        cellref-get {
539            if {[string toupper [string range [readexp "CRS$phase  ABC"] 34 34]] == "Y"} {
540                return 1
541            }
542            return 0
543        }
544        cellref-set {
545            if $value {
546                setexp "CRS$phase  ABC" "Y" 35 1
547            } else {
548                setexp "CRS$phase  ABC" "N" 35 1
549            }       
550        }
551        celldamp-get {
552            set val [string range [readexp "CRS$phase  ABC"] 39 39]
553            if {$val == " "} {return 0}
554            return $val
555        }
556        celldamp-set {
557            setexp "CRS$phase  ABC" $value 40 1
558        }
559
560        ODForder-get {
561            set val [string trim [string range [readexp "CRS$phase  ODF"] 0 4]]
562            if {$val == " "} {return 0}
563            return $val
564        }
565        ODForder-set {
566            if ![validint value 5] {return 0}
567            setexp "CRS$phase  ODF" $value 1 5
568        }
569        ODFsym-get {
570            set val [string trim [string range [readexp "CRS$phase  ODF"] 10 14]]
571            if {$val == " "} {return 0}
572            return $val
573        }
574        ODFsym-set {
575            if ![validint value 5] {return 0}
576            setexp "CRS$phase  ODF" $value 11 5
577        }
578        ODFdampA-get {
579            set val [string range [readexp "CRS$phase  ODF"] 24 24]
580            if {$val == " "} {return 0}
581            return $val
582        }
583        ODFdampA-set {
584            setexp "CRS$phase  ODF" $value 25 1
585        }
586        ODFdampC-get {
587            set val [string range [readexp "CRS$phase  ODF"] 29 29]
588            if {$val == " "} {return 0}
589            return $val
590        }
591        ODFdampC-set {
592            setexp "CRS$phase  ODF" $value 30 1
593        }
594        ODFomegaRef-get {
595            if {[string toupper [string range [readexp "CRS$phase  ODF"] 16 16]] == "Y"} {
596                return 1
597            }
598            return 0
599        }
600        ODFomegaRef-set {
601            if $value {
602                setexp "CRS$phase  ODF" "Y" 17 1
603            } else {
604                setexp "CRS$phase  ODF" "N" 17 1
605            }       
606        }
607        ODFchiRef-get {
608            if {[string toupper [string range [readexp "CRS$phase  ODF"] 17 17]] == "Y"} {
609                return 1
610            }
611            return 0
612        }
613        ODFchiRef-set {
614            if $value {
615                setexp "CRS$phase  ODF" "Y" 18 1
616            } else {
617                setexp "CRS$phase  ODF" "N" 18 1
618            }       
619        }
620        ODFphiRef-get {
621            if {[string toupper [string range [readexp "CRS$phase  ODF"] 18 18]] == "Y"} {
622                return 1
623            }
624            return 0
625        }
626        ODFphiRef-set {
627            if $value {
628                setexp "CRS$phase  ODF" "Y" 19 1
629            } else {
630                setexp "CRS$phase  ODF" "N" 19 1
631            }       
632        }
633        ODFcoef*-get {
634            regsub ODFcoef $parm {} term
635            set k [expr {($term+5)/6}]
636            if {$k <= 9} {set k " $k"}
637            set j [expr {(($term-1) % 6)+1}]
638            set lineB [readexp "CRS$phase  ODF${k}B"]
639            set j0 [expr { ($j-1) *10}]
640            set j1 [expr {$j0 + 9}]
641            set val [string trim [string range $lineB $j0 $j1]]
642            if {$val == ""} {return 0.0}
643            return $val
644        }
645        ODFcoef*-set {
646            regsub ODFcoef $parm {} term
647            if ![validreal value 10 3] {return 0}
648            set k [expr {($term+5)/6}]
649            if {$k <= 9} {set k " $k"}
650            set j [expr {(($term-1) % 6)+1}]
651            set col [expr { ($j-1)*10 + 1}]
652            setexp "CRS$phase  ODF${k}B" $value $col 10
653        }
654        ODFRefcoef-get {
655            if {[string toupper [string range [readexp "CRS$phase  ODF"] 19 19]] == "Y"} {
656                return 1
657            }
658            return 0
659        }
660        ODFRefcoef-set {
661            if $value {
662                setexp "CRS$phase  ODF" "Y" 20 1
663            } else {
664                setexp "CRS$phase  ODF" "N" 20 1
665            }       
666        }
667        ODFomega-get {
668           return [string trim [string range [readexp "CRS$phase  ODF"] 30 39]]
669        }
670        ODFchi-get {
671           return [string trim [string range [readexp "CRS$phase  ODF"] 40 49]]
672        }
673        ODFphi-get {
674           return [string trim [string range [readexp "CRS$phase  ODF"] 50 59]]
675        }
676        ODFomega-set {
677            if ![validreal value 10 4] {return 0}
678            setexp "CRS$phase  ODF" $value 31 10
679        }
680        ODFchi-set {
681            if ![validreal value 10 4] {return 0}
682            setexp "CRS$phase  ODF" $value 41 10
683        }
684        ODFphi-set {
685            if ![validreal value 10 4] {return 0}
686            setexp "CRS$phase  ODF" $value 51 10
687        }
688
689        ODFterms-get {
690            set vallist {}
691            set val [string trim [string range [readexp "CRS$phase  ODF"] 5 9]]
692            for {set i 1} {$i <= $val} {incr i 6} {
693                set k [expr {1+($i-1)/6}]
694                if {$k <= 9} {set k " $k"}
695                set lineA [readexp "CRS$phase  ODF${k}A"]
696                set k 0
697                for {set j $i} {$j <= $val && $j < $i+6} {incr j} {
698                    set j0 [expr {($k)*10}]
699                    set j1 [expr {$j0 + 9}]
700                    lappend vallist [string trim [string range $lineA $j0 $j1]]
701                    incr k
702                }
703            }
704            return $vallist
705        }
706        ODFterms-set {
707            set key "CRS$phase  ODF   "
708            if {![existsexp $key]} {
709                makeexprec $key
710                set oldlen 0
711            } else {
712                set oldlen [string trim [string range [readexp $key] 5 9]]
713            }
714            set len [llength $value]
715            if ![validint len 5] {return 0}
716            setexp $key $len 6 5
717            set j 0
718            set k 0
719            foreach item $value {
720                incr j
721                if {$j % 6 == 1} {
722                    incr k
723                    if {$k <= 9} {set k " $k"}
724                    set col 1
725                    set keyA "CRS$phase  ODF${k}A"
726                    set keyB "CRS$phase  ODF${k}B"
727                    if {![existsexp $keyA]} {
728                        makeexprec $keyA
729                        makeexprec $keyB
730                    }
731                }
732                set col1 [expr {$col + 1}]
733                foreach n [lrange $item 0 2] {
734                    if ![validint n 3] {return 0}
735                    setexp $keyA $n $col1 3
736                    incr col1 3
737                }
738                incr col 10
739            }
740            for {incr j} {$j <= $oldlen} {incr j} {
741                if {$j % 6 == 1} {
742                    incr k
743                    if {$k <= 9} {set k " $k"}
744                    set col 1
745                    set keyA "CRS$phase  ODF${k}A"
746                    set keyB "CRS$phase  ODF${k}B"
747                    delexp $keyA
748                    delexp $keyB
749                }
750                if {[existsexp $keyA]} {
751                    setexp $keyA "          " $col 10
752                    setexp $keyB "          " $col 10
753                }
754                incr col 10
755            }
756        }
757
758        default {
759            set msg "Unsupported phaseinfo access: parm=$parm action=$action"
760            tk_dialog .badexp "Error in readexp" $msg error 0 Exit
761        }
762    }
763    return 1
764}
765
766
767# get atom information: atominfo phase atom parm action value
768#   phase: 1 to 9 (as defined)
769#   atom: a valid atom number [see expmap(atomlist_$phase)]
770#      Note that atom and phase can be paired lists, but if there are extra
771#      entries in the atoms list, the last phase will be repeated.
772#      so that atominfo 1 {1 2 3} xset 1
773#               will set the xflag for atoms 1-3 in phase 1
774#      but atominfo {1 2 3} {1 1 1} xset 1
775#               will set the xflag for atoms 1 in phase 1-3
776#   parm:
777#     type -- element code
778#     mult -- atom multiplicity
779#     label -- atom label (*)
780#     x y z -- coordinates (*)
781#     frac --  occupancy (*)
782#     temptype -- I or A for Isotropic/Anisotropic (*)
783#     Uiso  -- Isotropic temperature factor (*)
784#     U11  -- Anisotropic temperature factor (*)
785#     U22  -- Anisotropic temperature factor (*)
786#     U33  -- Anisotropic temperature factor (*)
787#     U12  -- Anisotropic temperature factor (*)
788#     U13  -- Anisotropic temperature factor (*)
789#     U23  -- Anisotropic temperature factor (*)
790#     xref/xdamp -- refinement flag/damping value for the coordinates (*)
791#     uref/udamp -- refinement flag/damping value for the temperature factor(s)  (*)
792#     fref/fdamp -- refinement flag/damping value for the occupancy (*)
793#  action: get (default) or set
794#  value: used only with set
795#  * =>  read+write supported
796proc atominfo {phaselist atomlist parm "action get" "value {}"} {
797    foreach phase $phaselist atom $atomlist {
798        if {$phase == ""} {set phase [lindex $phaselist end]}
799        if {$atom < 10} {
800            set key "CRS$phase  AT  $atom"
801        } elseif {$atom < 100} {
802            set key "CRS$phase  AT $atom"
803        } else {
804            set key "CRS$phase  AT$atom"
805        }
806        switch -glob ${parm}-$action {
807            type-get {
808                return [string trim [string range [readexp ${key}A] 2 9] ]
809            }
810            mult-get {
811                return [string trim [string range [readexp ${key}A] 58 61] ]
812            }
813            label-get {
814                return [string trim [string range [readexp ${key}A] 50 57] ]
815            }
816            label-set {
817                setexp ${key}A $value 51 8
818            }
819            temptype-get {
820                return [string trim [string range [readexp ${key}B] 62 62] ]
821            }
822            temptype-set {
823                if {$value == "A"} {
824                    setexp ${key}B A 63 1
825                    # copy the Uiso to the diagonal terms
826                    set Uiso [string range [readexp ${key}B] 0 9]
827                    foreach value [CalcAniso $phase $Uiso] \
828                            col {1 11 21 31 41 51} {
829                        validreal value 10 6
830                        setexp ${key}B $value $col 10
831                    }
832                } else {
833                    setexp ${key}B I 63 1
834                    set value 0.0
835                    catch {
836                        # get the trace
837                        set value [expr {( \
838                                [string range [readexp ${key}B] 0 9] + \
839                                [string range [readexp ${key}B] 10 19] + \
840                                [string range [readexp ${key}B] 20 29])/3.}]
841                    }
842                    validreal value 10 6
843                    setexp ${key}B $value 1 10
844                    # blank out the remaining terms
845                    set value " "
846                    setexp ${key}B $value 11 10
847                    setexp ${key}B $value 21 10
848                    setexp ${key}B $value 31 10
849                    setexp ${key}B $value 41 10
850                    setexp ${key}B $value 51 10
851                }
852            }
853            x-get {
854                return [string trim [string range [readexp ${key}A] 10 19] ]
855            }
856            x-set {
857                if ![validreal value 10 6] {return 0}
858                setexp ${key}A $value 11 10
859            }
860            y-get {
861                return [string trim [string range [readexp ${key}A] 20 29] ]
862            }
863            y-set {
864                if ![validreal value 10 6] {return 0}
865                setexp ${key}A $value 21 10
866            }
867            z-get {
868                return [string trim [string range [readexp ${key}A] 30 39] ]
869            }
870            z-set {
871                if ![validreal value 10 6] {return 0}
872                setexp ${key}A $value 31 10
873            }
874            frac-get {
875                return [string trim [string range [readexp ${key}A] 40 49] ]
876            }
877            frac-set {
878                if ![validreal value 10 6] {return 0}
879                setexp ${key}A $value 41 10
880            }
881            U*-get {
882                regsub U $parm {} type
883                if {$type == "iso" || $type == "11"} {
884                    return [string trim [string range [readexp ${key}B] 0 9] ]
885                } elseif {$type == "22"} {
886                    return [string trim [string range [readexp ${key}B] 10 19] ]
887                } elseif {$type == "33"} {
888                    return [string trim [string range [readexp ${key}B] 20 29] ]
889                } elseif {$type == "12"} {
890                    return [string trim [string range [readexp ${key}B] 30 39] ]
891                } elseif {$type == "13"} {
892                    return [string trim [string range [readexp ${key}B] 40 49] ]
893                } elseif {$type == "23"} {
894                    return [string trim [string range [readexp ${key}B] 50 59] ]
895                }
896            }
897            U*-set {
898                if ![validreal value 10 6] {return 0}
899                regsub U $parm {} type
900                if {$type == "iso" || $type == "11"} {
901                    setexp ${key}B $value 1 10
902                } elseif {$type == "22"} {
903                    setexp ${key}B $value 11 10
904                } elseif {$type == "33"} {
905                    setexp ${key}B $value 21 10
906                } elseif {$type == "12"} {
907                    setexp ${key}B $value 31 10
908                } elseif {$type == "13"} {
909                    setexp ${key}B $value 41 10
910                } elseif {$type == "23"} {
911                    setexp ${key}B $value 51 10
912                }
913            }
914            xref-get {
915                if {[string toupper [string range [readexp ${key}B] 64 64]] == "X"} {
916                    return 1
917                }
918                return 0
919            }
920            xref-set {
921                if $value {
922                    setexp ${key}B "X" 65 1
923                } else {
924                    setexp ${key}B " " 65 1
925                }           
926            }
927            xdamp-get {
928                set val [string range [readexp ${key}A] 64 64]
929                if {$val == " "} {return 0}
930                return $val
931            }
932            xdamp-set {
933                setexp ${key}A $value 65 1
934            }
935            fref-get {
936                if {[string toupper [string range [readexp ${key}B] 63 63]] == "F"} {
937                    return 1
938                }
939                return 0
940            }
941            fref-set {
942                if $value {
943                    setexp ${key}B "F" 64 1
944                } else {
945                    setexp ${key}B " " 64 1
946                }           
947            }
948            fdamp-get {
949                set val [string range [readexp ${key}A] 63 63]
950                if {$val == " "} {return 0}
951                return $val
952            }
953            fdamp-set {
954                setexp ${key}A $value 64 1
955            }
956
957            uref-get {
958                if {[string toupper [string range [readexp ${key}B] 65 65]] == "U"} {
959                    return 1
960                }
961                return 0
962            }
963            uref-set {
964                if $value {
965                    setexp ${key}B "U" 66 1
966                } else {
967                    setexp ${key}B " " 66 1
968                }           
969            }
970            udamp-get {
971                set val [string range [readexp ${key}A] 65 65]
972                if {$val == " "} {return 0}
973                return $val
974            }
975            udamp-set {
976                setexp ${key}A $value 66 1
977            }
978            default {
979                set msg "Unsupported atominfo access: parm=$parm action=$action"
980                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
981            }
982        }
983    }
984    return 1
985}
986
987# get macromolecular atom information: mmatominfo phase atom parm action value
988#   phase: 1 (at present only one mm phase can be defined)
989#   atom: a valid atom number [see expmap(atomlist_$phase)]
990#      Note that atoms can be lists
991#      so that mmatominfo 1 {1 2 3} xset 1
992#               will set the xflag for atoms 1-3 in phase 1
993#   parm:
994#     type -- element code
995#     frac --  occupancy (*)
996#     x y z -- coordinates (*)
997#     Uiso  -- Isotropic temperature factor (*)
998#     label -- atom label (*)
999#     residue -- residue label (*)
1000#     group -- group label (*)
1001#     resnum -- residue number (*)
1002#     xref/xdamp -- refinement flag/damping value for the coordinates (*)
1003#     uref/udamp -- refinement flag/damping value for the temperature factor(s)  (*)
1004#     fref/fdamp -- refinement flag/damping value for the occupancy (*)
1005#  action: get (default) or set
1006#  value: used only with set
1007#  * =>  read+write supported
1008proc mmatominfo {phaselist atomlist parm "action get" "value {}"} {
1009    foreach phase $phaselist atom $atomlist {
1010        if {$phase == ""} {set phase [lindex $phaselist end]}
1011        set num [string toupper [format %.4x $atom]]
1012        set key "CRS$phase  AT$num"
1013        switch -glob ${parm}-$action {
1014            type-get {
1015                return [string trim [string range [readexp ${key}] 2 9] ]
1016            }
1017            frac-get {
1018                return [string trim [string range [readexp ${key}] 10 15] ]
1019            }
1020            frac-set {
1021                if ![validreal value 6 4] {return 0}
1022                setexp ${key} $value 11 6
1023            }
1024            x-get {
1025                return [string trim [string range [readexp ${key}] 16 23] ]
1026            }
1027            x-set {
1028                if ![validreal value 8 5] {return 0}
1029                setexp ${key} $value 17 8
1030            }
1031            y-get {
1032                return [string trim [string range [readexp ${key}] 24 31] ]
1033            }
1034            y-set {
1035                if ![validreal value 8 5] {return 0}
1036                setexp ${key} $value 25 8
1037            }
1038            z-get {
1039                return [string trim [string range [readexp ${key}] 32 39] ]
1040            }
1041            z-set {
1042                if ![validreal value 8 5] {return 0}
1043                setexp ${key} $value 33 8
1044            }
1045            Uiso-get {
1046                return [string trim [string range [readexp ${key}] 40 45] ]
1047            }
1048            Uiso-set {
1049                if ![validreal value 6 4] {return 0}
1050                setexp ${key} $value 41 6
1051            }
1052            label-get {
1053                return [string trim [string range [readexp ${key}] 46 50] ]
1054            }
1055            label-set {
1056                setexp ${key} $value 47 5
1057            }
1058            residue-get {
1059                return [string range [readexp ${key}] 51 53]
1060            }
1061            residue-set {
1062                setexp ${key} $value 52 3
1063            }
1064            group-get {
1065                return [string range [readexp ${key}] 54 55]
1066            }
1067            group-set {
1068                setexp ${key} $value 55 2
1069            }
1070            resnum-get {
1071                return [string trim [string range [readexp ${key}] 56 59] ]
1072            }
1073            resnum-set {
1074                if ![validint value 4] {return 0}
1075                setexp "${key} EPHAS" $value 57 4
1076            }
1077            fref-get {
1078                if {[string toupper [string range [readexp $key] 60 60]] == "F"} {
1079                    return 1
1080                }
1081                return 0
1082            }
1083            fref-set {
1084                if $value {
1085                    setexp $key "F" 61 1
1086                } else {
1087                    setexp $key " " 61 1
1088                }           
1089            }
1090            xref-get {
1091                if {[string toupper [string range [readexp $key] 61 61]] == "X"} {
1092                    return 1
1093                }
1094                return 0
1095            }
1096            xref-set {
1097                if $value {
1098                    setexp $key "X" 62 1
1099                } else {
1100                    setexp ${key}B " " 62 1
1101                }           
1102            }
1103            uref-get {
1104                if {[string toupper [string range [readexp $key] 62 62]] == "U"} {
1105                    return 1
1106                }
1107                return 0
1108            }
1109            uref-set {
1110                if $value {
1111                    setexp $key "U" 63 1
1112                } else {
1113                    setexp $key " " 63 1
1114                }           
1115            }
1116
1117            fdamp-get {
1118                set val [string range [readexp ${key}] 63 63]
1119                if {$val == " "} {return 0}
1120                return $val
1121            }
1122            fdamp-set {
1123                setexp ${key} $value 64 1
1124            }
1125            xdamp-get {
1126                set val [string range [readexp ${key}] 64 64]
1127                if {$val == " "} {return 0}
1128                return $val
1129            }
1130            xdamp-set {
1131                setexp ${key} $value 65 1
1132            }
1133
1134            udamp-get {
1135                set val [string range [readexp ${key}] 65 65]
1136                if {$val == " "} {return 0}
1137                return $val
1138            }
1139            udamp-set {
1140                setexp ${key} $value 66 1
1141            }
1142            default {
1143                set msg "Unsupported mmatominfo access: parm=$parm action=$action"
1144                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
1145            }
1146        }
1147    }
1148    return 1
1149}
1150
1151
1152
1153# get histogram information: histinfo histlist parm action value
1154# histlist is a list of histogram numbers
1155# parm:
1156#     title
1157#     file  -- file name of raw data for histogram (*)
1158#     scale (*)
1159#     sref/sdamp -- refinement flag/damping value for the scale factor (*)
1160#     lam1, lam2 (*)
1161#     ttref refinement flag for the 2theta (ED Xray) (*)
1162#     wref refinement flag for the wavelength (*)
1163#     ratref refinement flag for the wavelength ratio (*)
1164#     difc, difa -- TOF calibration constants (*)
1165#     dcref,daref -- refinement flag for difc, difa (*)
1166#     zero (*)
1167#     zref refinement flag for the zero correction (*)
1168#     ipola (*)
1169#     pola (*)
1170#     pref refinement flag for the polarization (*)
1171#     kratio (*)
1172#     ddamp -- damping value for the diffractometer constants (*)
1173#     backtype -- background function number *
1174#     backterms -- number of background terms *
1175#     bref/bdamp -- refinement flag/damping value for the background (*)
1176#     bterm$n -- background term #n (*)
1177#     bank -- Bank number
1178#     tofangle -- detector angle (TOF only)
1179#     foextract  -- Fobs extraction flag (*)
1180#     LBdamp  -- LeBail damping value (*)
1181#     tmin/tmax -- minimum & maximum usable 2theta/TOF/energy
1182#     excl -- excluded regions (*)
1183#     dmin -- minimum d-space for reflection generation (*)
1184#     use  -- use flag; 1 = use; 0 = do not use (*)
1185#     dstart -- dummy histogram starting tmin/emin/2theta (*)
1186#     dstep -- dummy histogram step size tmin/emin/2theta (*)
1187#     dpoints -- dummy histogram number of points (*)
1188#     dtype   -- dummy histogram type (CONST or SLOG)
1189#     abscor1 -- 1st absorption correction
1190#     abscor2 -- 2nd absorption correction
1191#     abstype -- absorption correction type
1192#   parameters transferred from the instrument parameter file:
1193#     ITYP    -- returns the contents of the ITYP record
1194proc histinfo {histlist parm "action get" "value {}"} {
1195    global expgui
1196    foreach hist $histlist {
1197        if {$hist < 10} {
1198            set key "HST  $hist"
1199        } else {
1200            set key "HST $hist"
1201        }
1202        switch -glob ${parm}-$action {
1203            foextract-get {
1204                set line [readexp "${key} EPHAS"]
1205                # add a EPHAS if not exists
1206                if {$line == {}} {
1207                    makeexprec "${key} EPHAS"
1208                    # expedt defaults this to "F", but I think "T" is better
1209                    setexp "${key} EPHAS" "Y" 50 1
1210                    if $expgui(debug) {puts "Warning: creating a ${key} EPHAS record"}
1211                }
1212                if {[string toupper [string range $line 49 49]] == "T"} {
1213                    return 1
1214                }
1215                # the flag has changed to "Y/N" in the latest versions
1216                # of GSAS
1217                if {[string toupper [string range $line 49 49]] == "Y"} {
1218                    return 1
1219                }
1220                return 0
1221            }
1222            foextract-set {
1223                # the flag has changed to "Y/N" in the latest versions
1224                # of GSAS
1225                if $value {
1226                    setexp "${key} EPHAS" "Y" 50 1
1227                } else {
1228                    setexp "${key} EPHAS" "N" 50 1
1229                }
1230            }
1231            LBdamp-get {
1232                set v [string trim [string range [readexp "${key} EPHAS"] 54 54]]
1233                if {$v == ""} {return 0}
1234                return $v
1235            }
1236            LBdamp-set {
1237                if ![validint value 5] {return 0}
1238                setexp "${key} EPHAS" $value 51 5
1239            }
1240            title-get {
1241                return [string trim [readexp "${key}  HNAM"] ]
1242            }
1243            scale-get {
1244                return [string trim [string range [readexp ${key}HSCALE] 0 14]]
1245            }
1246            scale-set {
1247                if ![validreal value 15 6] {return 0}
1248                setexp ${key}HSCALE $value 1 15
1249            }
1250            sref-get {
1251                if {[string toupper [string range [readexp ${key}HSCALE] 19 19]] == "Y"} {
1252                    return 1
1253                }
1254                return 0
1255            }
1256            sref-set {
1257                if $value {
1258                    setexp ${key}HSCALE "Y" 20 1
1259                } else {
1260                    setexp ${key}HSCALE "N" 20 1
1261                }           
1262            }
1263            sdamp-get {
1264                set val [string range [readexp ${key}HSCALE] 24 24]
1265                if {$val == " "} {return 0}
1266                return $val
1267            }
1268            sdamp-set {
1269                setexp ${key}HSCALE $value 25 1
1270            }
1271
1272            difc-get -
1273            lam1-get {
1274                return [string trim [string range [readexp "${key} ICONS"] 0 9]]
1275            }
1276            difc-set -
1277            lam1-set {
1278                if ![validreal value 10 7] {return 0}
1279                setexp "${key} ICONS" $value 1 10
1280            }
1281            difa-get -
1282            lam2-get {
1283                return [string trim [string range [readexp "${key} ICONS"] 10 19]]
1284            }
1285            difa-set -
1286            lam2-set {
1287                if ![validreal value 10 7] {return 0}
1288                setexp "${key} ICONS" $value 11 10
1289            }
1290            zero-get {
1291                return [string trim [string range [readexp "${key} ICONS"] 20 29]]
1292            }
1293            zero-set {
1294                if ![validreal value 10 5] {return 0}
1295                setexp "${key} ICONS" $value 21 10
1296            }
1297            ipola-get {
1298                return [string trim [string range [readexp "${key} ICONS"] 54 54]]
1299            }
1300            ipola-set {
1301                if ![validint value 1] {return 0}
1302                setexp "${key} ICONS" $value 55 1
1303            }
1304            pola-get {
1305                return [string trim [string range [readexp "${key} ICONS"] 40 49]]
1306            }
1307            pola-set {
1308                if ![validreal value 10 5] {return 0}
1309                setexp "${key} ICONS" $value 41 10
1310            }
1311            kratio-get {
1312                return [string trim [string range [readexp "${key} ICONS"] 55 64]]
1313            }
1314            kratio-set {
1315                if ![validreal value 10 5] {return 0}
1316                setexp "${key} ICONS" $value 56 10
1317            }
1318
1319            wref-get {
1320            #------------------------------------------------------
1321            # col 33: refine flag for lambda, difc, ratio and theta
1322            #------------------------------------------------------
1323                if {[string toupper [string range \
1324                        [readexp "${key} ICONS"] 32 32]] == "L"} {
1325                    return 1
1326                }
1327                return 0
1328            }
1329            wref-set {
1330                if $value {
1331                    setexp "${key} ICONS" "L" 33 1
1332                } else {
1333                    setexp "${key} ICONS" " " 33 1
1334                }           
1335            }
1336            ratref-get {
1337                if {[string toupper [string range \
1338                        [readexp "${key} ICONS"] 32 32]] == "R"} {
1339                    return 1
1340                }
1341                return 0
1342            }
1343            ratref-set {
1344                if $value {
1345                    setexp "${key} ICONS" "R" 33 1
1346                } else {
1347                    setexp "${key} ICONS" " " 33 1
1348                }           
1349            }
1350            dcref-get {
1351                if {[string toupper [string range \
1352                        [readexp "${key} ICONS"] 32 32]] == "C"} {
1353                    return 1
1354                }
1355                return 0
1356            }
1357            dcref-set {
1358                if $value {
1359                    setexp "${key} ICONS" "C" 33 1
1360                } else {
1361                    setexp "${key} ICONS" " " 33 1
1362                }           
1363            }
1364            ttref-get {
1365                if {[string toupper [string range \
1366                        [readexp "${key} ICONS"] 32 32]] == "T"} {
1367                    return 1
1368                }
1369                return 0
1370            }
1371            ttref-set {
1372                if $value {
1373                    setexp "${key} ICONS" "T" 33 1
1374                } else {
1375                    setexp "${key} ICONS" " " 33 1
1376                }           
1377            }
1378
1379
1380            pref-get {
1381            #------------------------------------------------------
1382            # col 34: refine flag for POLA & DIFA
1383            #------------------------------------------------------
1384                if {[string toupper [string range \
1385                        [readexp "${key} ICONS"] 33 33]] == "P"} {
1386                    return 1
1387                }
1388                return 0
1389            }
1390            pref-set {
1391                if $value {
1392                    setexp "${key} ICONS" "P" 34 1
1393                } else {
1394                    setexp "${key} ICONS" " " 34 1
1395                }           
1396            }
1397            daref-get {
1398                if {[string toupper [string range \
1399                        [readexp "${key} ICONS"] 33 33]] == "A"} {
1400                    return 1
1401                }
1402                return 0
1403            }
1404            daref-set {
1405                if $value {
1406                    setexp "${key} ICONS" "A" 34 1
1407                } else {
1408                    setexp "${key} ICONS" " " 34 1
1409                }           
1410            }
1411
1412            zref-get {
1413            #------------------------------------------------------
1414            # col 34: refine flag for zero correction
1415            #------------------------------------------------------
1416                if {[string toupper [string range [readexp "${key} ICONS"] 34 34]] == "Z"} {
1417                    return 1
1418                }
1419                return 0
1420            }
1421            zref-set {
1422                if $value {
1423                    setexp "${key} ICONS" "Z" 35 1
1424                } else {
1425                    setexp "${key} ICONS" " " 35 1
1426                }           
1427            }
1428
1429            ddamp-get {
1430                set val [string range [readexp "${key} ICONS"] 39 39]
1431                if {$val == " "} {return 0}
1432                return $val
1433            }
1434            ddamp-set {
1435                setexp "${key} ICONS" $value 40 1
1436            }
1437
1438            backtype-get {
1439                set val [string trim [string range [readexp "${key}BAKGD "] 0 4]]
1440                if {$val == " "} {return 0}
1441                return $val
1442            }
1443            backtype-set {
1444                if ![validint value 5] {return 0}
1445                setexp "${key}BAKGD " $value 1 5
1446            }
1447            backterms-get {
1448                set val [string trim [string range [readexp "${key}BAKGD "] 5 9]]
1449                if {$val == " "} {return 0}
1450                return $val
1451            }
1452            backterms-set {
1453                # this takes a bit of work -- if terms are added, add lines as needed to the .EXP
1454                set oldval [string trim [string range [readexp "${key}BAKGD "] 5 9]]
1455                if ![validint value 5] {return 0}
1456                if {$oldval < $value} {
1457                    set line1  [expr {2 + ($oldval - 1) / 4}]
1458                    set line2  [expr {1 + ($value - 1) / 4}]
1459                    for {set i $line1} {$i <= $line2} {incr i} {
1460                        # create a blank entry if needed
1461                        makeexprec ${key}BAKGD$i
1462                    }
1463                    incr oldval
1464                    for {set num $oldval} {$num <= $value} {incr num} {
1465                        set f1 [expr {15*(($num - 1) % 4)}]
1466                        set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
1467                        set line  [expr {1 + ($num - 1) / 4}]
1468                        if {[string trim [string range [readexp ${key}BAKGD$line] $f1 $f2]] == ""} {
1469                            set f1 [expr {15*(($num - 1) % 4)+1}]
1470                            setexp ${key}BAKGD$line 0.0 $f1 15                 
1471                        }
1472                    }
1473                }
1474                setexp "${key}BAKGD " $value 6 5
1475
1476            }
1477            bref-get {
1478                if {[string toupper [string range [readexp "${key}BAKGD"] 14 14]] == "Y"} {
1479                    return 1
1480                }
1481                return 0
1482            }
1483            bref-set {
1484                if $value {
1485                    setexp "${key}BAKGD "  "Y" 15 1
1486                } else {
1487                    setexp "${key}BAKGD "  "N" 15 1
1488                }
1489            }
1490            bdamp-get {
1491                set val [string range [readexp "${key}BAKGD "] 19 19]
1492                if {$val == " "} {return 0}
1493                return $val
1494            }
1495            bdamp-set {
1496                setexp "${key}BAKGD " $value 20 1
1497            }
1498            bterm*-get {
1499                regsub bterm $parm {} num
1500                set f1 [expr {15*(($num - 1) % 4)}]
1501                set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
1502                set line  [expr {1 + ($num - 1) / 4}]
1503                return [string trim [string range [readexp ${key}BAKGD$line] $f1 $f2] ]
1504            }
1505            bterm*-set {
1506                regsub bterm $parm {} num
1507                if ![validreal value 15 6] {return 0}
1508                set f1 [expr {15*(($num - 1) % 4)+1}]
1509                set line  [expr {1 + ($num - 1) / 4}]
1510                setexp ${key}BAKGD$line $value $f1 15
1511            }
1512            bank-get {
1513                return [string trim [string range [readexp "${key} BANK"] 0 4]]
1514            }
1515            tofangle-get {
1516                return [string trim [string range [readexp "${key}BNKPAR"] 10 19]]
1517            }
1518            tmin-get {
1519                return [string trim [string range [readexp "${key} TRNGE"] 0 9]]
1520            }
1521            tmax-get {
1522                return [string trim [string range [readexp "${key} TRNGE"] 10 19]]
1523            }
1524            excl-get {
1525                set n [string trim [string range [readexp "${key} NEXC"] 0 4]]
1526                set exlist {}
1527                for {set i 1} {$i <= $n} {incr i} {
1528                    lappend exlist \
1529                            [string trim [readexp [format "${key}EXC%3d" $i]]]
1530                }
1531                return $exlist
1532            }
1533            excl-set {
1534                set n [llength $value]
1535                if ![validint n 5] {return 0}
1536                setexp "${key} NEXC" $n 1 5
1537                set i 0
1538                foreach p $value {
1539                    incr i
1540                    foreach {r1 r2} $p {}
1541                    validreal r1 10 3
1542                    validreal r2 10 3
1543                    set k [format "${key}EXC%3d" $i]
1544                    if {![existsexp $k]} {
1545                        makeexprec $k
1546                    }
1547                    setexp $k ${r1}${r2} 1 20
1548                }
1549            }
1550            file-get {
1551                return [string trim [readexp "${key}  HFIL"] ]
1552            }
1553            file-set {
1554                setexp "${key}  HFIL" $value 3 65
1555            }
1556            bank-get {
1557                return [string trim [string range [readexp "${key} BANK"] 0 4]]
1558            }
1559            dmin-get {
1560                return [string trim [string range [readexp "${key} NREF"] 5 14]]
1561            }
1562            dmin-set {
1563                if ![validreal value 10 4] {return 0}
1564                setexp "${key} NREF" $value 6 10
1565            }
1566            use-get {
1567                set k [expr {($hist+11)/12}]
1568                set line [readexp " EXPR  HTYP$k"]
1569                set j [expr {((($hist-1) % 12)+1)*5}]
1570                if {[string range $line $j $j] == "*"} {return 0}
1571                return 1
1572            }
1573            use-set {
1574                set k [expr {($hist+11)/12}]
1575                set line [readexp " EXPR  HTYP$k"]
1576                set j [expr {((($hist-1) % 12)+1)*5+1}]
1577                if {$value} {
1578                    setexp " EXPR  HTYP$k" " " $j 1
1579                } else {
1580                    setexp " EXPR  HTYP$k" "*" $j 1
1581                }
1582            }
1583            dstart-get {
1584                return [string trim [string range [readexp "${key} DUMMY"] 20 29]]
1585            }
1586            dstart-set {
1587                if ![validreal value 10 3] {return 0}
1588                setexp "${key} DUMMY" $value 21 10
1589            }
1590            dstep-get {
1591                return [string trim [string range [readexp "${key} DUMMY"] 30 39]]
1592            }
1593            dstep-set {
1594                if ![validreal value 10 3] {return 0}
1595                setexp "${key} DUMMY" $value 31 10
1596            }
1597            dpoints-get {
1598                return [string trim [string range [readexp "${key} DUMMY"] 0 9]]
1599            }
1600            dpoints-set {
1601                if ![validint value 10] {return 0}
1602                setexp "${key} DUMMY" $value 1 10
1603            }
1604            dtype-get {
1605                return [string trim [string range [readexp "${key} DUMMY"] 10 19]]
1606            }
1607            abscor1-get {
1608                return [string trim [string range [readexp "${key}ABSCOR"] 0 14]]
1609            }
1610            abscor2-get {
1611                return [string trim [string range [readexp "${key}ABSCOR"] 15 29]]
1612            }
1613            abstype-get {
1614                return [string trim [string range [readexp "${key}ABSCOR"] 40 44]]
1615            }
1616            ITYP-get {
1617                return [string trim [readexp "${key}I ITYP"]]
1618            }
1619            default {
1620                set msg "Unsupported histinfo access: parm=$parm action=$action"
1621                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
1622            }
1623        }
1624    }
1625    return 1
1626}
1627
1628# read the information that differs by both histogram and phase (profile & phase fraction)
1629# use: hapinfo hist phase parm action value
1630
1631#     frac -- phase fraction (*)
1632#     frref/frdamp -- refinement flag/damping value for the phase fraction (*)
1633#     proftype -- profile function number (*)
1634#     profterms -- number of profile terms (*)
1635#     pdamp -- damping value for the profile (*)
1636#     pcut -- cutoff value for the profile (*)
1637#     pterm$n -- profile term #n (*)
1638#     pref$n -- refinement flag value for profile term #n (*)
1639#     extmeth -- Fobs extraction method (*)
1640#     POnaxis -- number of defined M-D preferred axes
1641proc hapinfo {histlist phaselist parm "action get" "value {}"} {
1642    foreach phase $phaselist hist $histlist {
1643        if {$phase == ""} {set phase [lindex $phaselist end]}
1644        if {$hist == ""} {set hist [lindex $histlist end]}
1645        if {$hist < 10} {
1646            set hist " $hist"
1647        }
1648        set key "HAP${phase}${hist}"
1649        switch -glob ${parm}-$action {
1650            extmeth-get {
1651                set i1 [expr {($phase - 1)*5}]
1652                set i2 [expr {$i1 + 4}]
1653                return [string trim [string range [readexp "HST $hist EPHAS"] $i1 $i2]]
1654            }
1655            extmeth-set {
1656                set i1 [expr {($phase - 1)*5 + 1}]
1657                if ![validint value 5] {return 0}
1658                setexp "HST $hist EPHAS" $value $i1 5
1659            }
1660            frac-get {
1661                return [string trim [string range [readexp ${key}PHSFR] 0 14]]
1662            }
1663            frac-set {
1664                if ![validreal value 15 6] {return 0}
1665                setexp ${key}PHSFR $value 1 15
1666            }
1667            frref-get {
1668                if {[string toupper [string range [readexp ${key}PHSFR] 19 19]] == "Y"} {
1669                    return 1
1670                }
1671                return 0
1672            }
1673            frref-set {
1674                if $value {
1675                    setexp ${key}PHSFR "Y" 20 1
1676                } else {
1677                    setexp ${key}PHSFR "N" 20 1
1678                }           
1679            }
1680            frdamp-get {
1681                set val [string range [readexp ${key}PHSFR] 24 24]
1682                if {$val == " "} {return 0}
1683                return $val
1684            }
1685            frdamp-set {
1686                setexp ${key}PHSFR $value 25 1
1687            }
1688            proftype-get {
1689                set val [string range [readexp "${key}PRCF "] 0 4]
1690                if {$val == " "} {return 0}
1691                return $val
1692            }
1693            proftype-set {
1694                if ![validint value 5] {return 0}
1695                setexp "${key}PRCF " $value 1 5
1696            }
1697            profterms-get {
1698                set val [string range [readexp "${key}PRCF "] 5 9]
1699                if {$val == " "} {return 0}
1700                return $val
1701            }
1702            profterms-set {
1703                if ![validint value 5] {return 0}
1704                setexp "${key}PRCF " $value 6 5
1705                # now check that all needed entries exist
1706                set lines [expr {1 + ($value - 1) / 4}]
1707                for {set i 1} {$i <= $lines} {incr i} {
1708                    makeexprec "${key}PRCF $i"
1709                }
1710            }
1711            pcut-get {
1712                return [string trim [string range [readexp "${key}PRCF "] 10 19]]
1713            }
1714            pcut-set {
1715                if ![validreal value 10 5] {return 0}
1716                setexp "${key}PRCF " $value 11 10
1717            }
1718            pdamp-get {
1719                set val [string range [readexp "${key}PRCF "] 24 24]
1720                if {$val == " "} {return 0}
1721                return $val
1722            }
1723            pdamp-set {
1724                setexp "${key}PRCF   " $value 25 1
1725            }
1726            pterm*-get {
1727                regsub pterm $parm {} num
1728                set f1 [expr {15*(($num - 1) % 4)}]
1729                set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
1730                set line  [expr {1 + ($num - 1) / 4}]
1731                return [string trim [string range [readexp "${key}PRCF $line"] $f1 $f2] ]
1732            }
1733            pterm*-set {
1734                if ![validreal value 15 6] {return 0}
1735                regsub pterm $parm {} num
1736                set f1 [expr {1+ 15*(($num - 1) % 4)}]
1737                set line  [expr {1 + ($num - 1) / 4}]
1738                setexp "${key}PRCF $line" $value $f1 15
1739            }
1740            pref*-get {
1741                regsub pref $parm {} num
1742                set f [expr {24+$num}]
1743                if {[string toupper [string range [readexp "${key}PRCF  "] $f $f]] == "Y"} {
1744                    return 1
1745                }
1746                return 0
1747            }
1748            pref*-set {
1749                regsub pref $parm {} num
1750                set f [expr {25+$num}]
1751                if $value {
1752                    setexp ${key}PRCF "Y" $f 1
1753                } else {
1754                    setexp ${key}PRCF "N" $f 1
1755                }           
1756            }
1757            POnaxis-get {
1758                set val [string trim \
1759                        [string range [readexp "${key}NAXIS"] 0 4]]
1760                if {$val == ""} {return 0}
1761                return $val
1762            }
1763            POnaxis-set {
1764                if ![validint value 5] {return 0}
1765                # there should be a NAXIS record, but if not make one
1766                if {![existsexp "${key}NAXIS"]} {
1767                    makeexprec "${key}NAXIS"
1768                }
1769                setexp "${key}NAXIS  " $value 1 5
1770            }
1771            default {
1772                set msg "Unsupported hapinfo access: parm=$parm action=$action"
1773                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
1774            }
1775        }
1776    }
1777    return 1
1778}
1779
1780#  get a logical constraint
1781#
1782#  type action
1783#  -----------
1784#  atom get  number        returns a list of constraints.
1785#   "   set  number value  replaces a list of constraints
1786#                          (value is a list of constraints)
1787#   "   add  number value  inserts a new list of constraints
1788#                          (number is ignored)
1789#   "   delete number      deletes a set of constraint entries
1790# Each item in the list of constraints is composed of 4 items:
1791#              phase, atom, variable, multiplier
1792# If variable=UISO atom can be ALL, otherwise atom is a number
1793# legal variable names: FRAC, X, Y, Z, UISO, U11, U22, U33, U12, U23, U13,
1794#                       MX, MY, MZ
1795#
1796#  type action
1797#  -----------
1798#  profileXX get number         returns a list of constraints for term XX=1-36
1799#                               use number=0 to get # of defined
1800#                                  constraints for term XX
1801#   "        set number value   replaces a list of constraints
1802#                               (value is a list of constraints)
1803#   "        add number value   inserts a new list of constraints
1804#                               (number is ignored)
1805#   "        delete number      deletes a set of constraint entries
1806# Each item in the list of constraints is composed of 3 items:
1807#              phase-list, histogram-list, multiplier
1808# Note that phase-list and/or histogram-list can be ALL
1809
1810proc constrinfo {type action number "value {}"} {
1811    global expmap
1812    if {[lindex $expmap(phasetype) 0] == 4} {
1813        set mm 1
1814    } else {
1815        set mm 0
1816    }
1817    switch -glob ${type}-$action {
1818        atom-get {
1819            # does this constraint exist?
1820            set key [format "LNCN%4d%4d" $number 1]
1821            if {![existsexp $key]} {return -1}
1822            set clist {}
1823            for {set i 1} {$i < 999} {incr i} {
1824                set key [format "LNCN%4d%4d" $number $i]
1825                if {![existsexp $key]} break
1826                set line [readexp $key]
1827                set j1 2
1828                set j2 17
1829                set seg [string range $line $j1 $j2]
1830                while {[string trim $seg] != ""} {
1831                    set p [string range $seg 0 0]
1832                    if {$p == 1 && $mm} {
1833                        set atom [string trim [string range $seg 1 4]]
1834                        set var [string trim [string range $seg 5 7]]
1835                        if {$atom == "ALL"} {
1836                            set var UIS
1837                        } else {
1838                            scan $atom %x atom
1839                        }
1840                        lappend clist [list $p $atom $var \
1841                                [string trim [string range $seg 8 end]]]
1842                    } else {
1843                        lappend clist [list $p \
1844                                [string trim [string range $seg 1 3]] \
1845                                [string trim [string range $seg 4 7]] \
1846                                [string trim [string range $seg 8 end]]]
1847                    }
1848                    incr j1 16
1849                    incr j2 16
1850                    set seg [string range $line $j1 $j2]
1851                }
1852            }
1853            return $clist
1854        }
1855        atom-set {
1856            # delete records for current constraint
1857            for {set i 1} {$i < 999} {incr i} {
1858                set key [format "LNCN%4d%4d" $number $i]
1859                if {![existsexp $key]} break
1860                delexp $key
1861            }
1862            set line {}
1863            set i 1
1864            foreach tuple $value {
1865                set p [lindex $tuple 0]
1866                if {$p == 1 && $mm && \
1867                        [string toupper [lindex $tuple 1]] == "ALL"} {
1868                    set seg [format %1dALL UIS%8.4f \
1869                            [lindex $tuple 0] \
1870                            [lindex $tuple 3]]
1871                } elseif {$p == 1 && $mm} {
1872                    set seg [eval format %1d%.4X%-3s%8.4f $tuple]
1873                } elseif {[string toupper [lindex $tuple 1]] == "ALL"} {
1874                    set seg [format %1dALL%-4s%8.4f \
1875                            [lindex $tuple 0] \
1876                            [lindex $tuple 2] \
1877                            [lindex $tuple 3]]
1878                } else {
1879                    set seg [eval format %1d%3d%-4s%8.4f $tuple]
1880                }
1881                append line $seg
1882                if {[string length $line] > 50} {
1883                    set key  [format "LNCN%4d%4d" $number $i]
1884                    makeexprec $key
1885                    setexp $key $line 3 68
1886                    set line {}
1887                    incr i
1888                }
1889            }
1890            if {$line != ""} {
1891                set key  [format "LNCN%4d%4d" $number $i]
1892                makeexprec $key
1893                setexp $key $line 3 68
1894            }
1895            return
1896        }
1897        atom-add {
1898            # loop over defined constraints
1899            for {set j 1} {$j < 9999} {incr j} {
1900                set key [format "LNCN%4d%4d" $j 1]
1901                if {![existsexp $key]} break
1902            }
1903            set number $j
1904            # save the constraint
1905            set line {}
1906            set i 1
1907            foreach tuple $value {
1908                set p [lindex $tuple 0]
1909                if {$p == 1 && $mm && \
1910                        [string toupper [lindex $tuple 1]] == "ALL"} {
1911                    set seg [format %1dALL UIS%8.4f \
1912                            [lindex $tuple 0] \
1913                            [lindex $tuple 3]]
1914                } elseif {$p == 1 && $mm} {
1915                    set seg [eval format %1d%.4X%-3s%8.4f $tuple]
1916                } elseif {[string toupper [lindex $tuple 1]] == "ALL"} {
1917                    set seg [format %1dALL%-4s%8.4f \
1918                            [lindex $tuple 0] \
1919                            [lindex $tuple 2] \
1920                            [lindex $tuple 3]]
1921                } else {
1922                    set seg [eval format %1d%3d%-4s%8.4f $tuple]
1923                }
1924                append line $seg
1925                if {[string length $line] > 50} {
1926                    set key  [format "LNCN%4d%4d" $number $i]
1927                    makeexprec $key
1928                    setexp $key $line 3 68
1929                    set line {}
1930                    incr i
1931                }
1932            }
1933            if {$line != ""} {
1934                set key  [format "LNCN%4d%4d" $number $i]
1935                makeexprec $key
1936                setexp $key $line 3 68
1937            }
1938            return
1939        }
1940        atom-delete {
1941            for {set j $number} {$j < 9999} {incr j} {
1942                # delete records for current constraint
1943                for {set i 1} {$i < 999} {incr i} {
1944                    set key [format "LNCN%4d%4d" $j $i]
1945                    if {![existsexp $key]} break
1946                    delexp $key
1947                }
1948                # now copy records, from the next entry, if any
1949                set j1 $j
1950                incr j1
1951                set key1 [format "LNCN%4d%4d" $j1 1]
1952                # if there is no record, there is nothing to copy -- done
1953                if {![existsexp $key1]} return
1954                for {set i 1} {$i < 999} {incr i} {
1955                    set key1 [format "LNCN%4d%4d" $j1 $i]
1956                    if {![existsexp $key1]} break
1957                    set key  [format "LNCN%4d%4d" $j  $i]
1958                    makeexprec $key
1959                    setexp $key [readexp $key1] 1 68
1960                }
1961            }
1962        }
1963        profile*-delete {
1964            regsub profile $type {} term
1965            if {$term < 10} {
1966                set term " $term"
1967            }
1968            set key "LEQV PF$term   "
1969            # return nothing if no term exists
1970            if {![existsexp $key]} {return 0}
1971
1972            # number of constraint terms
1973            set nterms [string trim [string range [readexp ${key}] 0 4] ]
1974            # don't delete a non-existing entry
1975            if {$number > $nterms} {return 0}
1976            set val [expr {$nterms - 1}]
1977            validint val 5
1978            setexp $key $val 1 5
1979            for {set i1 $number} {$i1 < $nterms} {incr i1} {
1980                set i2 [expr {1 + $i1}]
1981                # move the contents of constraint #i2 -> i1
1982                if {$i1 > 9} {
1983                    set k1 [expr {($i1+1)/10}]
1984                    set l1 $i1
1985                } else {
1986                    set k1 " "
1987                    set l1 " $i1"
1988                }
1989                set key1 "LEQV PF$term  $k1"
1990                # number of constraint lines for #i1
1991                set n1 [string trim [string range [readexp ${key1}] \
1992                        [expr {($i1%10)*5}] [expr {4+(($i1%10)*5)}]] ]
1993                if {$i2 > 9} {
1994                    set k2 [expr {($i2+1)/10}]
1995                    set l2 $i2
1996                } else {
1997                    set k2 " "
1998                    set l2 " $i2"
1999                }
2000                set key2 "LEQV PF$term  $k2"
2001                # number of constraint lines for #i2
2002                set n2 [string trim [string range [readexp ${key2}] \
2003                        [expr {($i2%10)*5}] [expr {4+(($i2%10)*5)}]] ]
2004                set val $n2
2005                validint val 5
2006                # move the # of terms
2007                setexp $key1 $val [expr {1+(($i1%10)*5)}] 5
2008                # move the terms
2009                for {set j 1} {$j <= $n2} {incr j 1} {
2010                    set key "LEQV PF${term}${l1}$j"
2011                    makeexprec $key
2012                    setexp $key [readexp "LEQV PF${term}${l2}$j"] 1 68
2013                }
2014                # delete any remaining lines
2015                for {set j [expr {$n2+1}]} {$j <= $n1} {incr j 1} {
2016                    delexp "LEQV PF${term}${l1}$j"
2017                }
2018            }
2019
2020            # clear the last term
2021            if {$nterms > 9} {
2022                set i [expr {($nterms+1)/10}]
2023            } else {
2024                set i " "
2025            }
2026            set key "LEQV PF$term  $i"
2027            set cb [expr {($nterms%10)*5}]
2028            set ce [expr {4+(($nterms%10)*5)}]
2029            set n2 [string trim [string range [readexp ${key}] $cb $ce] ]
2030            incr cb
2031            setexp $key "     " $cb 5
2032            # delete any remaining lines
2033            for {set j 1} {$j <= $n2} {incr j 1} {
2034                delexp "LEQV PF${term}${nterms}$j"
2035            }
2036        }
2037        profile*-set {
2038            regsub profile $type {} term
2039            if {$term < 10} {
2040                set term " $term"
2041            }
2042            set key "LEQV PF$term   "
2043            # get number of constraint terms
2044            set nterms [string trim [string range [readexp ${key}] 0 4] ]
2045            # don't change a non-existing entry
2046            if {$number > $nterms} {return 0}
2047            if {$number > 9} {
2048                set k1 [expr {($number+1)/10}]
2049                set l1 $number
2050            } else {
2051                set k1 " "
2052                set l1 " $number"
2053            }
2054            set key1 "LEQV PF$term  $k1"
2055            # old number of constraint lines
2056            set n1 [string trim [string range [readexp ${key1}] \
2057                    [expr {($number%10)*5}] [expr {4+(($number%10)*5)}]] ]
2058            # number of new constraints
2059            set j2 [llength $value]
2060            # number of new constraint lines
2061            set val [set n2 [expr {($j2 + 2)/3}]]
2062            # store the new # of lines
2063            validint val 5
2064            setexp $key1 $val [expr {1+(($number%10)*5)}] 5
2065
2066            # loop over the # of lines in the old or new, whichever is greater
2067            set v0 0
2068            for {set j 1} {$j <= [expr {($n1 > $n2) ? $n1 : $n2}]} {incr j 1} {
2069                set key "LEQV PF${term}${l1}$j"
2070                # were there more lines in the old?
2071                if {$j > $n2} {
2072                    # this line is not needed
2073                    if {$j % 3 == 1} {
2074                        delexp %key
2075                    }
2076                    continue
2077                }
2078                # are we adding new lines?
2079                if {$j > $n1} {
2080                    makeexprec $key
2081                }
2082                # add the three constraints to the line
2083                foreach s {3 23 43} \
2084                        item [lrange $value $v0 [expr {2+$v0}]] {
2085                    if {$item != ""} {
2086                        set val [format %-10s%9.3f \
2087                                [lindex $item 0],[lindex $item 1] \
2088                                [lindex $item 2]]
2089                        setexp $key $val $s 19
2090                    } else {
2091                        setexp $key " " $s 19
2092                    }
2093                }
2094                incr v0 3
2095            }
2096        }
2097        profile*-add {
2098            regsub profile $type {} term
2099            if {$term < 10} {
2100                set term " $term"
2101            }
2102            set key "LEQV PF$term   "
2103            if {![existsexp $key]} {makeexprec $key}
2104            set nterms [string trim [string range [readexp ${key}] 0 4] ]
2105            if {$nterms == ""} {
2106                set nterms 1
2107            } elseif {$nterms >= 99} {
2108                return 0
2109            } else {
2110                incr nterms
2111            }
2112            # store the new # of constraints
2113            set val $nterms
2114            validint val 5
2115            setexp $key $val 1 5
2116
2117            if {$nterms > 9} {
2118                set k1 [expr {($nterms+1)/10}]
2119                set l1 $nterms
2120            } else {
2121                set k1 " "
2122                set l1 " $nterms"
2123            }
2124            set key1 "LEQV PF$term  $k1"
2125
2126            # number of new constraints
2127            set j2 [llength $value]
2128            # number of new constraint lines
2129            set val [set n2 [expr {($j2 + 2)/3}]]
2130            # store the new # of lines
2131            validint val 5
2132            setexp $key1 $val [expr {1+(($nterms%10)*5)}] 5
2133
2134            # loop over the # of lines to be added
2135            set v0 0
2136            for {set j 1} {$j <= $n2} {incr j 1} {
2137                set key "LEQV PF${term}${l1}$j"
2138                makeexprec $key
2139                # add the three constraints to the line
2140                foreach s {3 23 43} \
2141                        item [lrange $value $v0 [expr {2+$v0}]] {
2142                    if {$item != ""} {
2143                        set val [format %-10s%9.3f \
2144                                [lindex $item 0],[lindex $item 1] \
2145                                [lindex $item 2]]
2146                        setexp $key $val $s 19
2147                    } else {
2148                        setexp $key " " $s 19
2149                    }
2150                }
2151                incr v0 3
2152            }
2153        }
2154        profile*-get {
2155            regsub profile $type {} term
2156            if {$term < 10} {
2157                set term " $term"
2158            }
2159            if {$number > 9} {
2160                set i [expr {($number+1)/10}]
2161            } else {
2162                set i " "
2163            }
2164            set key "LEQV PF$term  $i"
2165            # return nothing if no term exists
2166            if {![existsexp $key]} {return 0}
2167            # number of constraint lines
2168           
2169            set numline [string trim [string range [readexp ${key}] \
2170                    [expr {($number%10)*5}] [expr {4+(($number%10)*5)}]] ]
2171            if {$number == 0} {return $numline}
2172            set clist {}
2173            if {$number < 10} {
2174                set number " $number"
2175            }
2176            for {set i 1} {$i <= $numline} {incr i} {
2177                set key "LEQV PF${term}${number}$i"
2178                set line [readexp ${key}]
2179                foreach s {1 21 41} e {20 40 60} {
2180                    set seg [string range $line $s $e]
2181                    if {[string trim $seg] == ""} continue
2182                    # parse the string segment
2183                    set parse [regexp { *([0-9AL]+),([0-9AL]+) +([0-9.]+)} \
2184                            $seg junk phase hist mult]
2185                    # was parse successful
2186                    if {!$parse} {continue}
2187                    lappend clist [list $phase $hist $mult]
2188                }
2189            }
2190            return $clist
2191        }
2192        default {
2193            set msg "Unsupported constrinfo access: type=$type action=$action"
2194            tk_dialog .badexp "Error in readexp access" $msg error 0 OK
2195        }
2196
2197    }
2198}
2199
2200# read the default profile information for a histogram
2201# use: profdefinfo hist set# parm action
2202
2203#     proftype -- profile function number
2204#     profterms -- number of profile terms
2205#     pdamp -- damping value for the profile (*)
2206#     pcut -- cutoff value for the profile (*)
2207#     pterm$n -- profile term #n
2208#     pref$n -- refinement flag value for profile term #n (*)
2209
2210proc profdefinfo {hist set parm "action get"} {
2211    global expgui
2212    if {$hist < 10} {
2213        set key "HST  $hist"
2214    } else {
2215        set key "HST $hist"
2216    }
2217    switch -glob ${parm}-$action {
2218        proftype-get {
2219            set val [string range [readexp "${key}PRCF$set"] 0 4]
2220            if {$val == " "} {return 0}
2221            return $val
2222        }
2223        profterms-get {
2224            set val [string range [readexp "${key}PRCF$set"] 5 9]
2225            if {$val == " "} {return 0}
2226            return $val
2227        }
2228        pcut-get {
2229            return [string trim [string range [readexp "${key}PRCF$set"] 10 19]]
2230        }
2231        pdamp-get {
2232                set val [string range [readexp "${key}PRCF$set"] 24 24]
2233            if {$val == " "} {return 0}
2234            return $val
2235        }
2236        pterm*-get {
2237            regsub pterm $parm {} num
2238            set f1 [expr {15*(($num - 1) % 4)}]
2239            set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
2240            set line  [expr {1 + ($num - 1) / 4}]
2241            return [string trim [string range [\
2242                        readexp "${key}PRCF${set}$line"] $f1 $f2] ]
2243        }
2244        pref*-get {
2245            regsub pref $parm {} num
2246            set f [expr {24+$num}]
2247            if {[string toupper [string range [readexp "${key}PRCF$set"] $f $f]] == "Y"} {
2248                return 1
2249            }
2250            return 0
2251        }
2252        default {
2253            set msg "Unsupported profdefinfo access: parm=$parm action=$action"
2254            tk_dialog .badexp "Code Error" $msg error 0 Exit
2255        }
2256    }
2257}
2258
2259# get March-Dollase preferred orientation information
2260# use MDprefinfo hist phase axis-number parm action value
2261#    ratio    -- ratio of xtallites in PO direction vs random (>1 for more)
2262#    fraction -- fraction in this direction, when more than one axis is used
2263#    h k & l  -- indices of P.O. axis
2264#    ratioref -- flag to vary ratio
2265#    fracref  -- flag to vary fraction
2266#    damp     -- damping value
2267#    type     -- model type (0 = P.O. _|_ to beam, 1 = || to beam)
2268#    new      -- creates a new record with default values (set only)
2269proc MDprefinfo {histlist phaselist axislist parm "action get" "value {}"} {
2270    foreach phase $phaselist hist $histlist axis $axislist {
2271        if {$phase == ""} {set phase [lindex $phaselist end]}
2272        if {$hist == ""} {set hist [lindex $histlist end]}
2273        if {$axis == ""} {set axis [lindex $axislist end]}
2274        if {$hist < 10} {
2275            set hist " $hist"
2276        }
2277        if {$axis > 9} {
2278            set axis "0"
2279        }
2280        set key "HAP${phase}${hist}PREFO${axis}"
2281        switch -glob ${parm}-$action {
2282            ratio-get {
2283                return [string trim [string range [readexp $key] 0 9]]
2284            }
2285            ratio-set {
2286                if ![validreal value 10 6] {return 0}
2287                setexp $key $value 1 10
2288            }
2289            fraction-get {
2290                return [string trim [string range [readexp $key] 10 19]]
2291            }
2292            fraction-set {
2293                if ![validreal value 10 6] {return 0}
2294                setexp $key $value 11 10
2295            }
2296            h-get {
2297                set h [string trim [string range [readexp $key] 20 29]]
2298                # why not allow negative h values?
2299                #               if {$h < 1} {return 0}
2300                return $h
2301            }
2302            h-set {
2303                if ![validreal value 10 2] {return 0}
2304                setexp $key $value 21 10
2305            }
2306            k-get {
2307                set k [string trim [string range [readexp $key] 30 39]]
2308                #               if {$k < 1} {return 0}
2309                return $k
2310            }
2311            k-set {
2312                if ![validreal value 10 2] {return 0}
2313                setexp $key $value 31 10
2314            }
2315            l-get {
2316                set l [string trim [string range [readexp $key] 40 49]]
2317                #if {$l < 1} {return 0}
2318                return $l
2319            }
2320            l-set {
2321                if ![validreal value 10 2] {return 0}
2322                setexp $key $value 41 10
2323            }
2324            ratioref-get {
2325                if {[string toupper \
2326                        [string range [readexp $key] 53 53]] == "Y"} {
2327                    return 1
2328                }
2329                return 0
2330            }
2331            ratioref-set {
2332                if $value {
2333                    setexp $key "Y" 54 1
2334                } else {
2335                    setexp $key "N" 54 1
2336                }
2337            }
2338            fracref-get {
2339                if {[string toupper \
2340                        [string range [readexp $key] 54 54]] == "Y"} {
2341                    return 1
2342                }
2343                return 0
2344            }
2345            fracref-set {
2346                if $value {
2347                    setexp $key "Y" 55 1
2348                } else {
2349                    setexp $key "N" 55 1
2350              }
2351            }
2352            damp-get {
2353                set val [string trim [string range [readexp $key] 59 59]]
2354                if {$val == " "} {return 0}
2355                return $val
2356            }
2357            damp-set {
2358                setexp $key $value 60 1
2359            }
2360            type-get {
2361                set val [string trim [string range [readexp $key] 64 64]]
2362                if {$val == " "} {return 0}
2363                return $val
2364            }
2365            type-set {
2366                # only valid settings are 0 & 1
2367                if {$value != "0" && $value != "1"} {set value "0"}
2368                setexp $key $value 65 1
2369            }
2370            new-set {
2371                makeexprec $key
2372                setexp $key \
2373                        {  1.000000  1.000000  0.000000  0.000000  1.000000   NN    0    0} \
2374                        1 68
2375            }
2376            default {
2377                set msg "Unsupported MDprefinfo access: parm=$parm action=$action"
2378                tk_dialog .badexp "Error in readexp" $msg error 0 Exit
2379            }
2380
2381        }
2382
2383    }
2384}
2385
2386# write the .EXP file
2387proc expwrite {expfile} {
2388    global exparray
2389    set blankline \
2390     "                                                                        "
2391    set fp [open ${expfile} w]
2392    fconfigure $fp -translation crlf
2393    set keylist [lsort [array names exparray]]
2394    # reorder the keys so that VERSION comes 1st
2395    set pos [lsearch -exact $keylist {     VERSION}]
2396    set keylist "{     VERSION} [lreplace $keylist $pos $pos]"
2397    foreach key $keylist {
2398        puts $fp [string range \
2399                "$key$exparray($key)$blankline" 0 79]
2400    }
2401    close $fp
2402}
2403
2404# history commands -- delete all but last $keep history records,
2405# renumber if $renumber is true
2406proc DeleteHistory {keep renumber} {
2407    global exparray
2408    foreach y [lrange [lsort -decreasing \
2409            [array names exparray {    HSTRY*}]] $keep end] {
2410        unset exparray($y)
2411    }
2412    if !$renumber return
2413    # renumber
2414    set i 0
2415    foreach y [lsort -increasing \
2416            [array names exparray {    HSTRY*}]] {
2417        set key [format "    HSTRY%3d" [incr i]]
2418        set exparray($key) $exparray($y)
2419        unset exparray($y)
2420    }
2421    # list all history
2422    #    foreach y [lsort -decreasing [array names exparray {    HSTRY*}]] {puts "$y $exparray($y)"}
2423}
2424
2425proc CountHistory {} {
2426    global exparray
2427    return [llength [array names exparray {    HSTRY*}]]
2428}
2429
2430# set the phase flags for histogram $hist to $plist
2431proc SetPhaseFlag {hist plist} {
2432    # make a 2 digit key -- hh
2433    if {$hist < 10} {
2434        set hh " $hist"
2435    } else {
2436        set hh $hist
2437    }
2438    set key "HST $hh NPHAS"
2439    set str {}
2440    foreach iph {1 2 3 4 5 6 7 8 9} {
2441        if {[lsearch $plist $iph] != -1} {
2442            append str {    1}
2443        } else {
2444            append str {    0}     
2445        }
2446    }
2447    setexp $key $str 1 68
2448}
2449
2450# erase atom $atom from phase $phase
2451# update the list of atom types, erasing the record if not needed.
2452proc EraseAtom {atom phase} {
2453    set type [atominfo $phase $atom type]
2454    if {$type == ""} return
2455    if {$atom < 10} {
2456        set key "CRS$phase  AT  $atom"
2457    } elseif {$atom < 100} {
2458        set key "CRS$phase  AT $atom"
2459    } else {
2460        set key "CRS$phase  AT$atom"
2461    }
2462    # delete the records for the atom
2463    global exparray
2464    foreach k [array names exparray ${key}*] {
2465        delexp $k
2466    }
2467    # change the number of atoms in the phase
2468    phaseinfo $phase natoms set [expr {[phaseinfo $phase natoms] -1}]
2469
2470    # now adjust numbers in "EXPR ATYP" records and delete, if needed.
2471    set natypes [readexp " EXPR  NATYP"]
2472    if {$natypes == ""} return
2473    set j 0
2474    for {set i 1} {$i <= $natypes} {incr i} {
2475        incr j
2476        if {$j <10} {
2477            set key " EXPR ATYP $j"
2478        } else {
2479            set key " EXPR ATYP$j"
2480        }
2481        while {![existsexp $key]} {
2482            incr j
2483            if {$j > 99} {
2484                return
2485            } elseif {$j <10} {
2486                set key " EXPR ATYP $j"
2487            } else {
2488                set key " EXPR ATYP$j"
2489            }
2490        }
2491        set keytype [string trim [string range $exparray($key) 2 9]]
2492        if {$type == $keytype} {
2493            # found the type record
2494            set val [string trim [string range $exparray($key) 10 14]]
2495            incr val -1
2496            # if this is the last reference, remove the record,
2497            # otherwise, decrement the counter
2498            if {$val <= 0} {
2499                incr natypes -1 
2500                validint natypes 5
2501                setexp " EXPR  NATYP" $natypes 1 5
2502                delexp $key
2503            } else {
2504                validint val 5
2505                setexp $key $val 11 5
2506            }
2507            return
2508        }
2509    }
2510}
2511
2512# compute equivalent anisotropic temperature factor for Uequiv
2513proc CalcAniso {phase Uequiv} {
2514    foreach var {a b c alpha beta gamma} {
2515        set $var [phaseinfo $phase $var]
2516    }
2517
2518    set G(1,1) [expr {$a * $a}]
2519    set G(2,2) [expr {$b * $b}]
2520    set G(3,3) [expr {$c * $c}]
2521    set G(1,2) [expr {$a * $b * cos($gamma*0.017453292519943)}]
2522    set G(2,1) $G(1,2)
2523    set G(1,3) [expr {$a * $c * cos($beta *0.017453292519943)}]
2524    set G(3,1) $G(1,3)
2525    set G(2,3) [expr {$b * $c * cos($alpha*0.017453292519943)}]
2526    set G(3,2) $G(2,3)
2527
2528    # Calculate the volume**2
2529    set v2 0.0
2530    foreach i {1 2 3} {
2531        set J [expr {($i%3) + 1}]
2532        set K [expr {(($i+1)%3) + 1}]
2533        set v2 [expr {$v2+ $G(1,$i)*($G(2,$J)*$G(3,$K)-$G(3,$J)*$G(2,$K))}]
2534    }
2535    if {$v2 > 0} {
2536        set v [expr {sqrt($v2)}]
2537        foreach i {1 2 3} {
2538            set i1 [expr {($i%3) + 1}]
2539            set i2 [expr {(($i+1)%3) + 1}]
2540            foreach j {1 2 3} {
2541                set j1 [expr {($j%3) + 1}]
2542                set j2 [expr {(($j+1)%3) + 1}]
2543                set C($j,$i) [expr {(\
2544                        $G($i1,$j1) * $G($i2,$j2) - \
2545                        $G($i1,$j2)  * $G($i2,$j1)\
2546                        )/ $v}]
2547            }
2548        }
2549        set A(1,2) [expr {0.5 * ($C(1,2)+$C(2,1)) / sqrt( $C(1,1)* $C(2,2) )}]
2550        set A(1,3) [expr {0.5 * ($C(1,3)+$C(3,1)) / sqrt( $C(1,1)* $C(3,3) )}]
2551        set A(2,3) [expr {0.5 * ($C(2,3)+$C(3,2)) / sqrt( $C(2,2)* $C(3,3) )}]
2552        foreach i {1 1 2} j {2 3 3} {
2553            set A($i,$j) [expr {0.5 * ($C($i,$j) + $C($j,$i)) / \
2554                    sqrt( $C($i,$i)* $C($j,$j) )}]
2555            # clean up roundoff
2556            if {abs($A($i,$j)) < 1e-5} {set A($i,$j) 0.0}
2557        }
2558    } else {
2559        set A(1,2) 0.0
2560        set A(1,3) 0.0
2561        set A(2,3) 0.0
2562    }
2563    return "$Uequiv $Uequiv $Uequiv \
2564            [expr {$Uequiv * $A(1,2)}] \
2565            [expr {$Uequiv * $A(1,3)}] \
2566            [expr {$Uequiv * $A(2,3)}]"
2567}
Note: See TracBrowser for help on using the repository browser.